package api

import (
	"fmt"
	"kontor-api-gin/internal/config"
	"kontor-api-gin/internal/models"
	"log/slog"

	"resty.dev/v3"
)

type Login struct {
	Email    string
	Password string
}

type LoginResponse struct {
	Token string
}

type ExportData struct {
	Sport              models.SportDTOList              `json:"sport"`
	Player             models.PlayerDTOList             `json:"player"`
	Team               models.TeamDTOList               `json:"team"`
	Position           models.PositionDTOList           `json:"field_position"`
	Rooster            models.RoosterDTOList            `json:"rooster"`
	Vendor             models.VendorDTOList             `json:"vendor"`
	CardSet            models.CardSetDTOList            `json:"card_set"`
	Card               models.CardDTOList               `json:"card"`
	Artist             models.ArtistDTOList             `json:"artist"`
	Publisher          models.PublisherDTOList          `json:"publisher"`
	Worktype           models.WorkTypeDTOList           `json:"worktype"`
	Comic              models.ComicDTOList              `json:"comic"`
	Volume             models.VolumeDTOList             `json:"volume"`
	StoryArc           models.StoryArcDTOList           `json:"story_arc"`
	Issue              models.IssueDTOList              `json:"issue"`
	TradePaperback     models.TradePaperbackDTOList     `json:"trade_paperback"`
	ComicWork          models.ComicworkDTOList          `json:"comic_work"`
	IssueWork          models.IssueworkDTOList          `json:"issue_work"`
	Article            models.ArticleDTOList            `json:"article"`
	BookshelfPublisher models.BookshelfPublisherDTOList `json:"bookshelf_publisher"`
	Book               models.BookDTOList               `json:"book"`
	Author             models.AuthorDTOList             `json:"author"`
	ArticleAuthor      models.ArticleAuthorDTOList      `json:"article_author"`
	BookAuthor         models.BookAuthorDTOList         `json:"book_author"`
	MediaArticle       models.MediaArticleDTOList       `json:"media_article"`
	MediaVideo         models.MediaVideoDTOList         `json:"media_video"`
	MediaLoFi          models.MediaLoFiDTOList          `json:"media_lofi"`
	MediaMusic         models.MediaMusicDTOList         `json:"media_music"`
	MediaFile          models.MediaFileDTOList          `json:"media_file"`
	MediaActor         models.MediaActorDTOList         `json:"media_actor"`
	MediaActorFile     models.MediaActorFileDTOList     `json:"media_actor_file"`
	Profile            models.ProfileDTOList            `json:"profile"`
	Permission         models.PermissionDTOList         `json:"permission"`
	Assignment         models.AssignmentDTOList         `json:"assignment"`
	Token              models.TokenDTOList              `json:"token"`
	MailAccount        models.MailAccountDTOList        `json:"mail_account"`
	Mail               models.MailDTOList               `json:"mail"`
}

func (e *ExportData) GetMap() map[string]any {
	dataMap := make(map[string]any)
	for path, value := range Registry {
		switch path {
		case "tysc/sports":
			dataMap["sports"] = value
		case "tysc/players":
			dataMap["players"] = value
		}
	}
	return dataMap
}

var (
	Sports               models.SportDTOList
	Players              models.PlayerDTOList
	Teams                models.TeamDTOList
	Positions            models.PositionDTOList
	Roosters             models.RoosterDTOList
	Vendors              models.VendorDTOList
	Cardsets             models.CardSetDTOList
	Cards                models.CardDTOList
	Artists              models.ArtistDTOList
	Publishers           models.PublisherDTOList
	Worktypes            models.WorkTypeDTOList
	Comics               models.ComicDTOList
	Volumes              models.VolumeDTOList
	Storyarcs            models.StoryArcDTOList
	Issues               models.IssueDTOList
	Tradepaperbacks      models.TradePaperbackDTOList
	Comicworks           models.ComicworkDTOList
	Issueworks           models.IssueworkDTOList
	Articles             models.ArticleDTOList
	Bookshelf_publishers models.BookshelfPublisherDTOList
	Books                models.BookDTOList
	Authors              models.AuthorDTOList
	Article_authors      models.ArticleAuthorDTOList
	Book_authors         models.BookAuthorDTOList
	Mediaarticles        models.MediaArticleDTOList
	Mediavideos          models.MediaVideoDTOList
	Mediaactors          models.MediaActorDTOList
	Mediaactorfiles      models.MediaActorFileDTOList
	Mediafiles           models.MediaFileDTOList
	Medialofis           models.MediaLoFiDTOList
	MediaMusics          models.MediaMusicDTOList
	Profiles             models.ProfileDTOList
	Permissions          models.PermissionDTOList
	Assignments          models.AssignmentDTOList
	Tokens               models.TokenDTOList
	Mailaccounts         models.MailAccountDTOList
	Mail                 models.MailDTOList
)

var Registry map[string]any

func GetToken(client *resty.Client, server config.Server) (token string) {
	var login LoginResponse
	body := Login{
		Email:    server.Username,
		Password: server.Password,
	}
	PostJSON(client, server, "", "api", "login", body, &login)

	// _, err := client.R().
	// 	SetBody(body).
	// 	SetHeader("Accept", "application/json").
	// 	SetResult(&login).
	// 	Post(fmt.Sprintf("%s/api/login", server.Url))
	// if err != nil {
	// 	slog.Info("Health", "error", err.Error())
	// }
	if config.Verbose > 2 {
		slog.Info("login", "token", login.Token)
	}
	return login.Token
}

func GetData(server config.Server, apiVersion string) (data *ExportData, err error) {
	client := resty.New()
	client.SetLoggerWarnLevel(true)
	token := GetToken(client, server)

	for path, value := range Registry {
		GetJSON(client, token, server, path, value)
	}
	export := ExportData{
		Sport:              Sports,
		Player:             Players,
		Team:               Teams,
		Position:           Positions,
		Rooster:            Roosters,
		Vendor:             Vendors,
		CardSet:            Cardsets,
		Card:               Cards,
		Artist:             Artists,
		Publisher:          Publishers,
		Worktype:           Worktypes,
		Comic:              Comics,
		Volume:             Volumes,
		StoryArc:           Storyarcs,
		Issue:              Issues,
		TradePaperback:     Tradepaperbacks,
		ComicWork:          Comicworks,
		IssueWork:          Issueworks,
		Article:            Articles,
		BookshelfPublisher: Bookshelf_publishers,
		Book:               Books,
		Author:             Authors,
		ArticleAuthor:      Article_authors,
		BookAuthor:         Book_authors,
		MediaArticle:       Mediaarticles,
		MediaVideo:         Mediavideos,
		MediaActor:         Mediaactors,
		MediaActorFile:     Mediaactorfiles,
		MediaFile:          Mediafiles,
		MediaLoFi:          Medialofis,
		MediaMusic:         MediaMusics,
		Profile:            Profiles,
		Permission:         Permissions,
		Assignment:         Assignments,
		Token:              Tokens,
		MailAccount:        Mailaccounts,
		Mail:               Mail,
	}
	defer client.Close()
	return &export, nil
}

func DeleteData(target config.Server, path, id string) {
	slog.Info("DeleteData")
	url := fmt.Sprintf("%s/%s/%s/%s", target.Url, config.Config.ApiVersion, path, id)
	client := resty.New()
	client.SetLoggerWarnLevel(true)
	token := GetToken(client, target)
	_, err := client.R().
		SetAuthToken(token).
		SetHeader("Accept", "application/json").
		Delete(url)
	if err != nil {
		slog.Info(url, "error", err.Error())
	}
}

func PushData(target config.Server, path string, data any, result any) (response *resty.Response, err error) {
	url := fmt.Sprintf("%s/%s/%s", target.Url, config.Config.ApiVersion, path)
	client := resty.New()
	token := GetToken(client, target)
	response, err = client.R().
		SetBody(data).
		SetAuthToken(token).
		SetHeader("Accept", "application/json").
		SetResult(result).
		Post(url)
	return response, err
}

func UpdateData(target config.Server, path string, v any) {
	client := resty.New()
	client.SetLoggerWarnLevel(true)
	token := GetToken(client, target)
	var result any
	PostJSON(client, target, token, config.Config.ApiVersion, path, v, &result)
}

func GetJSON(client *resty.Client, token string, server config.Server, path string, v any) {
	url := fmt.Sprintf("%s/%s/%s", server.Url, config.Config.ApiVersion, path)
	if config.Verbose > 2 {
		slog.Info("GetJSON", "url", url)
	}
	var err error
	if token == "" {
		_, err = client.R().
			SetHeader("Accept", "application/json").
			SetResult(v).
			Get(url)
	} else {
		_, err = client.R().
			SetAuthToken(token).
			SetHeader("Accept", "application/json").
			SetResult(v).
			Get(url)
	}
	if err != nil {
		slog.Info(url, "error", err.Error())
	}
	if config.Verbose > 2 {
		slog.Info("GetJSON", "value", v)
	}
}

func PostJSON(client *resty.Client, server config.Server, token string, apiVersion string, path string, body any, v any) {
	url := fmt.Sprintf("%s/%s/%s", server.Url, apiVersion, path)
	if config.Verbose > 2 {
		slog.Info("PostJSON", "url", url)
	}
	response, err := client.R().
		SetAuthToken(token).
		SetBody(body).
		SetHeader("Accept", "application/json").
		SetResult(v).
		Post(url)
	if err != nil {
		slog.Info("PostJSON", "error", err.Error())
	}
	if config.Verbose > 2 {
		slog.Info("PostJSON", "response", response)
	}
}

func init() {
	Registry = map[string]any{
		"tysc/sports":              &Sports,
		"tysc/players":             &Players,
		"tysc/teams":               &Teams,
		"tysc/positions":           &Positions,
		"tysc/roosters":            &Roosters,
		"tysc/vendors":             &Vendors,
		"tysc/cardsets":            &Cardsets,
		"tysc/cards":               &Cards,
		"comics/artists":           &Artists,
		"comics/publishers":        &Publishers,
		"comics/worktypes":         &Worktypes,
		"comics/comics":            &Comics,
		"comics/volumes":           &Volumes,
		"comics/storyarcs":         &Storyarcs,
		"comics/issues":            &Issues,
		"comics/tradepaperbacks":   &Tradepaperbacks,
		"comics/comicworks":        &Comicworks,
		"comics/issueworks":        &Issueworks,
		"bookshelf/articles":       &Articles,
		"bookshelf/publishers":     &Bookshelf_publishers,
		"bookshelf/books":          &Books,
		"bookshelf/authors":        &Authors,
		"bookshelf/articleauthors": &Article_authors,
		"bookshelf/bookauthors":    &Book_authors,
		"media/articles":           &Mediaarticles,
		"media/videos":             &Mediavideos,
		"media/actors":             &Mediaactors,
		"media/files":              &Mediafiles,
		"media/actorfiles":         &Mediaactorfiles,
		"media/lofis":              &Medialofis,
		"media/musics":             &MediaMusics,
		"user/profiles":            &Profiles,
		"user/permissions":         &Permissions,
		"user/assignments":         &Assignments,
		"user/tokens":              &Tokens,
		"admin/mailaccounts":       &Mailaccounts,
		"user/mail":                &Mail,
	}
}