package function

import (
	"errors"
	"log"

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

	"gorm.io/gorm"
)

type Function struct {
	gorm.Model
	Name         string                    `gorm:"primaryKey uniqueIndex index" 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
	Tags         []string
	Requirements []string
}

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 {
	Id, idOk := context.GetQuery("id")
	Tags, tagsOK := context.GetQueryArray("tags")
	Requirements, requirementsOK := context.GetQueryArray("requirements")
	if idOk && tagsOK && requirementsOK {
		params.Id = Id
		if len(Tags) > 0 {
			params.Tags = Tags
		}
		if len(Requirements) > 0 {
			params.Requirements = Requirements
		}
	} else {
		return errors.New("One or more parameters not included in request")
	}
	return nil
}

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

func (function Function) Update(db *gorm.DB) error {
	var originalFunction Function
	originalFunction.Get(db, 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
	}
	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.Id,
		Tags:         *functiontag.Get(db, params.Tags),
		Requirements: *Get(db, params.Requirements),
	}.Create(db)
}

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

func GetAll(db *gorm.DB) *[]Function {
	var outputFunctionNames []string
	result := db.Model(&Function{}).Select("name").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
	}
	return Function{
		Name:         params.Id,
		Tags:         *functiontag.Get(db, params.Tags),
		Requirements: *Get(db, params.Requirements),
	}.Update(db)
}

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