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 CreateDatabasePerson(db *gorm.DB, person databasemodels.Person) error {
	result := db.Create(&person)
	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 CreateDatabaseCharacter(db *gorm.DB, character databasemodels.Character) error {
	result := db.Create(&character)
	if result.Error != nil {
		return result.Error
	}
	return nil
}

func CreateDatabaseRole(db *gorm.DB, role databasemodels.Role) error {
	result := db.Create(&role)
	if result.Error != nil {
		return result.Error
	}
	return nil
}

func CreateDatabaseTier(db *gorm.DB, tier databasemodels.Tier) error {
	result := db.Create(&tier)
	if result.Error != nil {
		return result.Error
	}
	return nil
}

func CreateDatabaseFunctionSet(db *gorm.DB, functionSet databasemodels.FunctionSet) error {
	result := db.Create(&functionSet)
	if result.Error != nil {
		return result.Error
	}
	return nil
}

func CreateDatabaseFunction(db *gorm.DB, function databasemodels.Function) error {
	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
}

func CreateDatabaseInventorySlot(db *gorm.DB, inventorySlot databasemodels.InventorySlot) error {
	result := db.Create(&inventorySlot)
	if result.Error != nil {
		return result.Error
	}
	return nil
}

func CreateDatabaseItem(db *gorm.DB, item databasemodels.Item) error {
	result := db.Create(&item)
	if result.Error != nil {
		return result.Error
	}
	return nil
}

func CreateDatabaseItemTag(db *gorm.DB, itemTag databasemodels.ItemTag) error {
	result := db.Create(&itemTag)
	if result.Error != nil {
		return result.Error
	}
	return nil
}

func CreateDatabaseCustomization(db *gorm.DB, customization databasemodels.Customization) error {
	result := db.Create(&customization)
	if result.Error != nil {
		return result.Error
	}
	return nil
}

func CreateDatabaseSchematic(db *gorm.DB, schematic databasemodels.Schematic) error {
	result := db.Create(&schematic)
	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
	result := db.Where("id = ?", discordId).Take(&queryUser)
	if errors.Is(result.Error, gorm.ErrRecordNotFound) {
		return false
	} else {
		return queryUser.LoggedIn
	}
}

func GetDatabasePerson(db *gorm.DB, inputPerson string) databasemodels.Person {
	var outputPerson databasemodels.Person
	result := db.Model(&databasemodels.Person{}).Where("name = ?", inputPerson).Take(&outputPerson)
	if result.Error != nil {
		return databasemodels.Person{}
	}
	db.Model(&outputPerson).Association("Groups").Find(&outputPerson.Groups)
	return outputPerson
}

func GetDatabasePersons(db *gorm.DB, inputPersons []string) []databasemodels.Person {
	var outputPersons []databasemodels.Person
	for _, inputPerson := range inputPersons {
		outputPersons = append(outputPersons, GetDatabasePerson(db, inputPerson))
	}
	return outputPersons
}

func GetAllDatabasePersons(db *gorm.DB) []databasemodels.Person {
	var outputPersons []databasemodels.Person
	result := db.Find(&outputPersons)
	if result.Error != nil {
		log.Println(result.Error)
	}
	for index, outputPerson := range outputPersons {
		outputPersons[index] = GetDatabasePerson(db, outputPerson.Name)
	}
	return outputPersons
}

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, inputGroups []string) []databasemodels.Group {
	var outputGroups []databasemodels.Group
	for _, inputGroup := range inputGroups {
		outputGroups = append(outputGroups, GetDatabaseGroup(db, inputGroup))
	}
	return outputGroups
}

func GetAllDatabaseGroups(db *gorm.DB) []databasemodels.Group {
	var outputGroups []databasemodels.Group
	result := db.Find(&outputGroups)
	if result.Error != nil {
		log.Println(result.Error)
	}
	for index, outputGroup := range outputGroups {
		outputGroups[index] = GetDatabaseGroup(db, outputGroup.Name)
	}
	return outputGroups
}

func GetDatabaseCharacter(db *gorm.DB, inputCharacter string) databasemodels.Character {
	var outputCharacter databasemodels.Character
	result := db.Model(&databasemodels.Character{}).Where("name = ?", inputCharacter).Take(&outputCharacter)
	if result.Error != nil {
		return databasemodels.Character{}
	}
	db.Model(&outputCharacter).Association("Owners").Find(&outputCharacter.Owners)
	db.Model(&outputCharacter).Association("Roles").Find(&outputCharacter.Roles)
	db.Model(&outputCharacter).Association("FunctionSets").Find(&outputCharacter.FunctionSets)
	db.Model(&outputCharacter).Association("Inventory").Find(&outputCharacter.Inventory)
	return outputCharacter
}

func GetDatabaseCharacters(db *gorm.DB, inputCharacters []string) []databasemodels.Character {
	var outputCharacters []databasemodels.Character
	for _, inputCharacter := range inputCharacters {
		outputCharacters = append(outputCharacters, GetDatabaseCharacter(db, inputCharacter))
	}
	return outputCharacters
}

func GetAllDatabaseCharacters(db *gorm.DB) []databasemodels.Character {
	var outputCharacters []databasemodels.Character
	result := db.Find(&outputCharacters)
	if result.Error != nil {
		log.Println(result.Error)
	}
	for index, outputCharacter := range outputCharacters {
		outputCharacters[index] = GetDatabaseCharacter(db, outputCharacter.Name)
	}
	return outputCharacters
}

func GetDatabaseRole(db *gorm.DB, inputRole string) databasemodels.Role {
	var outputRole databasemodels.Role
	result := db.Model(&databasemodels.Role{}).Where("name = ?", inputRole).Take(&outputRole)
	if result.Error != nil {
		return databasemodels.Role{}
	}
	db.Model(&outputRole).Association("Tiers").Find(&outputRole.Tiers)
	db.Model(&outputRole).Association("Visibility").Find(&outputRole.Visibility)
	return outputRole
}

func GetDatabaseRoles(db *gorm.DB) []databasemodels.Role {
	var outputRoles []databasemodels.Role
	db.Find(&outputRoles)
	for _, outputRole := range outputRoles {
		outputRoles = append(outputRoles, GetDatabaseRole(db, outputRole.Name))
	}
	return outputRoles
}

func GetAllDatabaseRoles(db *gorm.DB) []databasemodels.Role {
	var outputRoles []databasemodels.Role
	result := db.Find(&outputRoles)
	if result.Error != nil {
		log.Println(result.Error)
	}
	for index, outputRole := range outputRoles {
		outputRoles[index] = GetDatabaseRole(db, outputRole.Name)
	}
	return outputRoles
}

func GetDatabaseTier(db *gorm.DB, inputTier int) databasemodels.Tier {
	var outputTier databasemodels.Tier
	result := db.Model(&databasemodels.Tier{}).Where("id = ?", inputTier).Take(&outputTier)
	if result.Error != nil {
		return databasemodels.Tier{}
	}
	db.Model(&outputTier).Association("FunctionSets").Find(&outputTier.FunctionSets)
	return outputTier
}

func GetDatabaseTiers(db *gorm.DB, inputTiers []int) []databasemodels.Tier {
	var outputTiers []databasemodels.Tier
	for _, inputTier := range inputTiers {
		outputTiers = append(outputTiers, GetDatabaseTier(db, inputTier))
	}
	return outputTiers
}

func GetAllDatabaseTiers(db *gorm.DB) []databasemodels.Tier {
	var outputTiers []databasemodels.Tier
	result := db.Find(&outputTiers)
	if result.Error != nil {
		log.Println(result.Error)
	}
	for index, outputTier := range outputTiers {
		outputTiers[index] = GetDatabaseTier(db, int(outputTier.ID))
	}
	return outputTiers
}

func GetDatabaseFunctionSet(db *gorm.DB, inputFunctionSet int) databasemodels.FunctionSet {
	var outputFunctionSet databasemodels.FunctionSet
	result := db.Model(&databasemodels.FunctionSet{}).Where("id = ?", inputFunctionSet).Take(&outputFunctionSet)
	if result.Error != nil {
		return databasemodels.FunctionSet{}
	}
	db.Model(&outputFunctionSet).Association("Functions").Find(&outputFunctionSet.Functions)
	return outputFunctionSet
}

func GetDatabaseFunctionSets(db *gorm.DB, inputFunctionSets []int) []databasemodels.FunctionSet {
	var outputFunctionSets []databasemodels.FunctionSet
	db.Find(&outputFunctionSets)
	for _, inputFunctionSet := range inputFunctionSets {
		outputFunctionSets = append(outputFunctionSets, GetDatabaseFunctionSet(db, inputFunctionSet))
	}
	return outputFunctionSets
}

func GetAllDatabaseFunctionSets(db *gorm.DB) []databasemodels.FunctionSet {
	var outputFunctionSets []databasemodels.FunctionSet
	result := db.Find(&outputFunctionSets)
	if result.Error != nil {
		log.Println(result.Error)
	}
	for index, outputFunctionSet := range outputFunctionSets {
		outputFunctionSets[index] = GetDatabaseFunctionSet(db, int(outputFunctionSet.ID))
	}
	return outputFunctionSets
}

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{}
	}
	db.Model(&outputFunction).Association("Tags").Find(&outputFunction.Tags)
	db.Model(&outputFunction).Association("Requirements").Find(&outputFunction.Requirements)
	return outputFunction
}

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

func GetAllDatabaseFunctions(db *gorm.DB) []databasemodels.Function {
	var outputFunctions []databasemodels.Function
	result := db.Find(&outputFunctions)
	if result.Error != nil {
		log.Println(result.Error)
	}
	for index, outputFunction := range outputFunctions {
		outputFunctions[index] = GetDatabaseFunction(db, outputFunction.Name)
	}
	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, inputFunctionTags []string) []databasemodels.FunctionTag {
	var outputFunctionTags []databasemodels.FunctionTag
	for _, inputFunctionTag := range inputFunctionTags {
		outputFunctionTags = append(outputFunctionTags, GetDatabaseFunctionTag(db, inputFunctionTag))
	}
	return outputFunctionTags
}

func GetAllDatabaseFunctionTags(db *gorm.DB) []databasemodels.FunctionTag {
	var outputFunctionTags []databasemodels.FunctionTag
	result := db.Find(&outputFunctionTags)
	if result.Error != nil {
		log.Println(result.Error)
	}
	for index, outputFunctionTag := range outputFunctionTags {
		outputFunctionTags[index] = GetDatabaseFunctionTag(db, outputFunctionTag.Name)
	}
	return outputFunctionTags
}

func GetDatabaseInventorySlot(db *gorm.DB, inputInventorySlot int) databasemodels.InventorySlot {
	var outputInventorySlot databasemodels.InventorySlot
	result := db.Model(&databasemodels.InventorySlot{}).Where("id = ?", inputInventorySlot).Take(&outputInventorySlot)
	if result.Error != nil {
		return databasemodels.InventorySlot{}
	}
	db.Model(&outputInventorySlot).Association("Item").Find(&outputInventorySlot.Item)
	return outputInventorySlot
}

func GetDatabaseInventorySlots(db *gorm.DB, inputInventorySlots []int) []databasemodels.InventorySlot {
	var outputInventorySlots []databasemodels.InventorySlot
	for _, inputInventorySlot := range inputInventorySlots {
		outputInventorySlots = append(outputInventorySlots, GetDatabaseInventorySlot(db, inputInventorySlot))
	}
	return outputInventorySlots
}

func GetAllDatabaseInventorySlots(db *gorm.DB) []databasemodels.InventorySlot {
	var outputInventorySlots []databasemodels.InventorySlot
	result := db.Find(&outputInventorySlots)
	if result.Error != nil {
		log.Println(result.Error)
	}
	for index, outputInventorySlot := range outputInventorySlots {
		outputInventorySlots[index] = GetDatabaseInventorySlot(db, int(outputInventorySlot.ID))
	}
	return outputInventorySlots
}

func GetDatabaseItem(db *gorm.DB, inputItem string) databasemodels.Item {
	var outputItem databasemodels.Item
	result := db.Model(&databasemodels.Item{}).Where("name = ?", inputItem).Take(&outputItem)
	if result.Error != nil {
		return databasemodels.Item{}
	}
	db.Model(&outputItem).Association("Functions").Find(&outputItem.Functions)
	db.Model(&outputItem).Association("Tags").Find(&outputItem.Tags)
	db.Model(&outputItem).Association("Customizations").Find(&outputItem.Customizations)
	db.Model(&outputItem).Association("Visibility").Find(&outputItem.Visibility)
	return outputItem
}

func GetDatabaseItems(db *gorm.DB, inputItems []string) []databasemodels.Item {
	var outputItems []databasemodels.Item
	for _, inputItem := range inputItems {
		outputItems = append(outputItems, GetDatabaseItem(db, inputItem))
	}
	return outputItems
}

func GetAllDatabaseItems(db *gorm.DB) []databasemodels.Item {
	var outputItems []databasemodels.Item
	result := db.Find(&outputItems)
	if result.Error != nil {
		log.Println(result.Error)
	}
	for index, outputItem := range outputItems {
		outputItems[index] = GetDatabaseItem(db, outputItem.Name)
	}
	return outputItems
}

func GetDatabaseItemTag(db *gorm.DB, inputItemTag string) databasemodels.ItemTag {
	var outputItemTag databasemodels.ItemTag
	result := db.Model(&databasemodels.ItemTag{}).Where("name = ?", outputItemTag).Take(&outputItemTag)
	if result.Error != nil {
		return databasemodels.ItemTag{}
	}
	return outputItemTag
}

func GetDatabaseItemTags(db *gorm.DB, inputItemTags []string) []databasemodels.ItemTag {
	var outputItemTags []databasemodels.ItemTag
	for _, inputItemTag := range inputItemTags {
		outputItemTags = append(outputItemTags, GetDatabaseItemTag(db, inputItemTag))
	}
	return outputItemTags
}

func GetAllDatabaseItemTags(db *gorm.DB) []databasemodels.ItemTag {
	var outputItemTags []databasemodels.ItemTag
	result := db.Find(&outputItemTags)
	if result.Error != nil {
		log.Println(result.Error)
	}
	for index, outputItemTag := range outputItemTags {
		outputItemTags[index] = GetDatabaseItemTag(db, outputItemTag.Name)
	}
	return outputItemTags
}

func GetDatabaseCustomization(db *gorm.DB, inputCustomization string) databasemodels.Customization {
	var outputCustomization databasemodels.Customization
	result := db.Model(&databasemodels.Customization{}).Where("name = ?", inputCustomization).Take(&outputCustomization)
	if result.Error != nil {
		return databasemodels.Customization{}
	}
	db.Model(&outputCustomization).Association("Functions").Find(&outputCustomization.Functions)
	db.Model(&outputCustomization).Association("Tags").Find(&outputCustomization.Tags)
	db.Model(&outputCustomization).Association("Visibility").Find(&outputCustomization.Visibility)
	return outputCustomization
}

func GetDatabaseCustomizations(db *gorm.DB, inputCustomizations []string) []databasemodels.Customization {
	var outputCustomizations []databasemodels.Customization
	for _, inputCustomization := range inputCustomizations {
		outputCustomizations = append(outputCustomizations, GetDatabaseCustomization(db, inputCustomization))
	}
	return outputCustomizations
}

func GetAllDatabaseCustomizations(db *gorm.DB) []databasemodels.Customization {
	var outputCustomizations []databasemodels.Customization
	result := db.Find(&outputCustomizations)
	if result.Error != nil {
		log.Println(result.Error)
	}
	for index, outputCustomization := range outputCustomizations {
		outputCustomizations[index] = GetDatabaseCustomization(db, outputCustomization.Name)
	}
	return outputCustomizations
}

func GetDatabaseSchematic(db *gorm.DB, inputSchematic int) databasemodels.Schematic {
	var outputSchematic databasemodels.Schematic
	result := db.Model(&databasemodels.Schematic{}).Where("id = ?", inputSchematic).Take(&outputSchematic)
	if result.Error != nil {
		return databasemodels.Schematic{}
	}
	db.Model(&outputSchematic).Association("Material").Find(&outputSchematic.Material)
	db.Model(&outputSchematic).Association("Tools").Find(&outputSchematic.Tools)
	db.Model(&outputSchematic).Association("Requirements").Find(&outputSchematic.Requirements)
	db.Model(&outputSchematic).Association("Result").Find(&outputSchematic.Result)
	db.Model(&outputSchematic).Association("Visibility").Find(&outputSchematic.Visibility)
	return outputSchematic
}

func GetDatabaseSchematics(db *gorm.DB, inputSchematics []int) []databasemodels.Schematic {
	var outputSchematics []databasemodels.Schematic
	for _, inputSchematic := range inputSchematics {
		outputSchematics = append(outputSchematics, GetDatabaseSchematic(db, inputSchematic))
	}
	return outputSchematics
}

func GetAllDatabaseSchematics(db *gorm.DB) []databasemodels.Schematic {
	var outputSchematics []databasemodels.Schematic
	result := db.Find(&outputSchematics)
	if result.Error != nil {
		log.Println(result.Error)
	}
	for index, outputSchematic := range outputSchematics {
		outputSchematics[index] = GetDatabaseSchematic(db, int(outputSchematic.ID))
	}
	return outputSchematics
}

// 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
}

func UpdateDatabasePerson(db *gorm.DB, person databasemodels.Person) error {
	result := db.Save(&person)
	if result.Error != nil {
		return result.Error
	}
	return nil
}

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

func UpdateDatabaseCharacter(db *gorm.DB, character databasemodels.Character) error {
	result := db.Save(&character)
	if result.Error != nil {
		return result.Error
	}
	return nil
}

func UpdateDatabaseRole(db *gorm.DB, role databasemodels.Role) error {
	result := db.Save(&role)
	if result.Error != nil {
		return result.Error
	}
	return nil
}

func UpdateDatabaseTier(db *gorm.DB, tier databasemodels.Tier) error {
	result := db.Save(&tier)
	if result.Error != nil {
		return result.Error
	}
	return nil
}

func UpdateDatabaseFunctionSet(db *gorm.DB, functionSet databasemodels.FunctionSet) error {
	result := db.Save(&functionSet)
	if result.Error != nil {
		return result.Error
	}
	return nil
}

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

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

func UpdateDatabaseInventorySlot(db *gorm.DB, inventoySlot databasemodels.InventorySlot) error {
	result := db.Save(&inventoySlot)
	if result.Error != nil {
		return result.Error
	}
	return nil
}

func UpdateDatabaseItem(db *gorm.DB, item databasemodels.Item) error {
	result := db.Save(&item)
	if result.Error != nil {
		return result.Error
	}
	return nil
}

func UpdateDatabaseItemTag(db *gorm.DB, itemTag databasemodels.ItemTag) error {
	result := db.Save(&itemTag)
	if result.Error != nil {
		return result.Error
	}
	return nil
}

func UpdateDatabaseCustomization(db *gorm.DB, customization databasemodels.Customization) error {
	result := db.Save(&customization)
	if result.Error != nil {
		return result.Error
	}
	return nil
}

func UpdateDatabaseSchematic(db *gorm.DB, schematic databasemodels.Schematic) error {
	result := db.Save(&schematic)
	if result.Error != nil {
		return result.Error
	}
	return nil
}

// Delete Functions