package function

import (
	"encoding/json"
	"io"
	"log"
	"strconv"

	functiontag "example.com/database/functiontag"
	"github.com/gin-gonic/gin"

	"gorm.io/gorm"
)

type Function struct {
	gorm.Model
	Name         string                    `gorm:"uniqueIndex" json:"name"`
	Tags         []functiontag.FunctionTag `gorm:"many2many:function_tag_associations" json:"tags"`
	Requirements []Function                `gorm:"many2many:function_requirement_associations" json:"requirements"`
}

type functionParams struct {
	Id           string `json:"id"`
	Name         string `json:"name"`
	Tags         []uint `json:"tags"`
	Requirements []uint `json:"requirements"`
}

func (function Function) Create(db *gorm.DB) error {
	result := db.Create(&function)
	if result.Error != nil {
		return result.Error
	}
	return nil
}

func (function *Function) getAssociations(db *gorm.DB) {
	db.Model(&function).Association("Tags").Find(&function.Tags)
	db.Model(&function).Association("Requirements").Find(&function.Requirements)
}

func (params *functionParams) validate(context *gin.Context) error {
	body, err := io.ReadAll(context.Request.Body)
	if err != nil {
		log.Println(err)
		return err
	}
	log.Println(string(body))
	var newParams functionParams
	err = json.Unmarshal(body, &newParams)
	log.Println(err, newParams)
	params.Id = newParams.Id
	params.Name = newParams.Name
	params.Tags = newParams.Tags
	params.Requirements = newParams.Requirements
	return nil
}

func (function *Function) Get(db *gorm.DB, inputFunction uint) {
	db.Where("id = ?", inputFunction).Take(&function)
	function.getAssociations(db)
}

func (function Function) update(db *gorm.DB) error {
	var originalFunction Function
	result := db.Model(&Function{}).Where("id = ?", function.Model.ID).Take(&originalFunction)
	if result.Error != nil {
		return result.Error
	}
	originalFunction.Name = function.Name
	tagsError := db.Model(&originalFunction).Association("Tags").Replace(&function.Tags)
	if tagsError != nil {
		return tagsError
	}
	requirementsError := db.Model(&originalFunction).Association("Requirements").Replace(&function.Requirements)
	if requirementsError != nil {
		return requirementsError
	}
	db.Save(&originalFunction)
	return nil
}

func (function Function) Delete(db *gorm.DB) error {
	result := db.Delete(&function)
	if result.Error != nil {
		return result.Error
	}
	return nil
}

func Create(db *gorm.DB, context *gin.Context) error {
	var params functionParams
	err := params.validate(context)
	if err != nil {
		return err
	}
	return Function{
		Name:         params.Name,
		Tags:         *functiontag.Get(db, params.Tags),
		Requirements: *Get(db, params.Requirements),
	}.Create(db)
}

func Get(db *gorm.DB, inputFunctions []uint) *[]Function {
	var outputFunctions []Function
	for _, inputFunction := range inputFunctions {
		var outputFunction Function
		outputFunction.Get(db, inputFunction)
		outputFunctions = append(outputFunctions, outputFunction)
	}
	log.Println(outputFunctions)
	return &outputFunctions
}

func GetAll(db *gorm.DB) *[]Function {
	var outputFunctionNames []uint
	result := db.Model(&Function{}).Select("id").Find(&outputFunctionNames)
	if result.Error != nil {
		log.Println(result.Error)
	}
	return Get(db, outputFunctionNames)
}

func Update(db *gorm.DB, context *gin.Context) error {
	var params functionParams
	err := params.validate(context)
	if err != nil {
		return err
	}
	uintID, err := strconv.Atoi(params.Id)
	if err != nil {
		return err
	}
	return Function{
		Model:        gorm.Model{ID: uint(uintID)},
		Name:         params.Name,
		Tags:         *functiontag.Get(db, params.Tags),
		Requirements: *Get(db, params.Requirements),
	}.update(db)
}

func Delete(db *gorm.DB, inputFunctions []uint) error {
	functions := Get(db, inputFunctions)
	log.Println(inputFunctions, functions)
	for _, function := range *functions {
		err := function.Delete(db)
		if err != nil {
			return err
		}
	}
	return nil
}