package databasecommands

import (
	"errors"
	"log"

	databasemodels "example.com/database/models"

	"gorm.io/driver/sqlite"
	"gorm.io/gorm"
)

func InitializeDatabase() *gorm.DB {
	db, err := gorm.Open(sqlite.Open("../db/main.db"), &gorm.Config{})
	if err != nil {
		log.Fatal("Failed to connect to database.")
	}
	db.AutoMigrate(
		&databasemodels.User{},
		&databasemodels.Group{},
		&databasemodels.FunctionTag{},
		&databasemodels.ItemTag{},
		&databasemodels.Function{},
		&databasemodels.FunctionSet{},
		&databasemodels.Tier{},
		&databasemodels.Role{},
		&databasemodels.Person{},
		&databasemodels.Item{},
		&databasemodels.InventorySlot{},
		&databasemodels.Character{},
		&databasemodels.Customization{},
		&databasemodels.Schematic{},
	)
	return db
}

// Create Functions

func CreateDatabaseUser(db *gorm.DB, user databasemodels.User) error {
	result := db.Create(&user)
	if result.Error != nil {
		return result.Error
	}
	return nil
}

func CreateDatabaseGroup(db *gorm.DB, group databasemodels.Group) error {
	result := db.Create(&group)
	if result.Error != nil {
		return result.Error
	}
	return nil
}

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

func CreateDatabaseFunctionTag(db *gorm.DB, functionTag databasemodels.FunctionTag) error {
	result := db.Create(&functionTag)
	if result.Error != nil {
		return result.Error
	}
	return nil
}

// Read Functions

func GetDatabaseUserToken(db *gorm.DB, id string) string {
	var dbUser databasemodels.User
	result := db.Where("id = ?", id).Select("login_token").Take(&dbUser)
	if errors.Is(result.Error, gorm.ErrRecordNotFound) {
		return ""
	} else {
		return dbUser.LoginToken
	}
}

func GetDatabaseUserExists(db *gorm.DB, id string) bool {
	var queryUser databasemodels.User
	result := db.Where("id = ?", id).Take(&queryUser)
	if errors.Is(result.Error, gorm.ErrRecordNotFound) {
		return false
	} else {
		return true
	}
}

func GetDatabaseUserLoggedIn(db *gorm.DB, oauthTokenJSON string) bool {
	var queryUser databasemodels.User
	result := db.Where("login_token = ?", oauthTokenJSON).Take(&queryUser)
	if errors.Is(result.Error, gorm.ErrRecordNotFound) {
		return false
	} else {
		return queryUser.LoggedIn
	}
}

func GetDatabaseUserLoggedInFromDiscordId(db *gorm.DB, discordId string) bool {
	var queryUser databasemodels.User
	var result *gorm.DB
	result = db.Where("id = ?", discordId).Take(&queryUser)
	if errors.Is(result.Error, gorm.ErrRecordNotFound) {
		return false
	} else {
		return queryUser.LoggedIn
	}
}

func GetDatabaseGroup(db *gorm.DB, inputGroup string) databasemodels.Group {
	var outputGroup databasemodels.Group
	result := db.Model(&databasemodels.Group{}).Where("name = ?", inputGroup).Take(&outputGroup)
	if result.Error != nil {
		return databasemodels.Group{}
	}
	return outputGroup
}

func GetDatabaseGroups(db *gorm.DB) []string {
	var outputGroups []databasemodels.Group
	var outputGroupsList []string
	result := db.Find(&outputGroups)
	if result.Error != nil {
		return outputGroupsList
	} else {
		for _, group := range outputGroups {
			outputGroupsList = append(outputGroupsList, group.Name)
		}
		return outputGroupsList
	}
}

func GetDatabaseFunction(db *gorm.DB, inputFunction string) databasemodels.Function {
	var outputFunction databasemodels.Function
	result := db.Model(&databasemodels.Function{}).Where("name = ?", inputFunction).Take(&outputFunction)
	if result.Error != nil {
		return databasemodels.Function{}
	}
	return outputFunction
}

func GetDatabaseFunctions(db *gorm.DB) []databasemodels.Function {
	var outputFunctions []databasemodels.Function
	db.Find(&outputFunctions)
	for outputFunctionId, outputFunction := range outputFunctions {
		var outputFunctionTags []databasemodels.FunctionTag
		db.Model(&outputFunction).Association("Tags").Find(&outputFunctionTags)
		var outputFunctionRequirements []databasemodels.Function
		db.Model(&outputFunction).Association("Requirements").Find(&outputFunctionRequirements)
		outputFunctions[outputFunctionId].Tags = outputFunctionTags
		outputFunctions[outputFunctionId].Requirements = outputFunctionRequirements
	}
	log.Printf("Functions: %v", outputFunctions)
	return outputFunctions
}

func GetDatabaseFunctionTag(db *gorm.DB, inputFunctionTag string) databasemodels.FunctionTag {
	var outputFunctionTag databasemodels.FunctionTag
	result := db.Model(&databasemodels.FunctionTag{}).Where("name = ?", inputFunctionTag).Take(&outputFunctionTag)
	if result.Error != nil {
		return databasemodels.FunctionTag{}
	}
	return outputFunctionTag
}

func GetDatabaseFunctionTags(db *gorm.DB) []string {
	var outputFunctionTags []databasemodels.FunctionTag
	var outputFunctionTagsList []string
	result := db.Find(&outputFunctionTags)
	if result.Error != nil {
		return outputFunctionTagsList
	} else {
		for _, functionTag := range outputFunctionTags {
			outputFunctionTagsList = append(outputFunctionTagsList, functionTag.Name)
		}
		return outputFunctionTagsList
	}
}

// Update Functions

func LogoutDatabaseUser(db *gorm.DB, oauthToken string) {
	db.Model(&databasemodels.User{}).Where("login_token = ?", oauthToken).Update("logged_in", false)
}

func UpdateDatabaseUser(db *gorm.DB, user databasemodels.User) error {
	result := db.Save(&user)
	if result.Error != nil {
		return result.Error
	}
	return nil
}

// Delete Functions