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.TeamDTO               `json:"team"`
	Position           []models.PositionDTO           `json:"field_position"`
	Rooster            []models.RoosterDTO            `json:"rooster"`
	Vendor             []models.VendorDTO             `json:"vendor"`
	CardSet            []models.CardSetDTO            `json:"card_set"`
	Card               []models.CardDTO               `json:"card"`
	Artist             []models.ArtistDTO             `json:"artist"`
	Publisher          []models.PublisherDTO          `json:"publisher"`
	Worktype           []models.WorkTypeDTO           `json:"worktype"`
	Comic              []models.ComicDTO              `json:"comic"`
	Volume             []models.VolumeDTO             `json:"volume"`
	StoryArc           []models.StoryArcDTO           `json:"story_arc"`
	Issue              []models.IssueDTO              `json:"issue"`
	TradePaperback     []models.TradePaperbackDTO     `json:"trade_paperback"`
	ComicWork          []models.ComicworkDTO          `json:"comic_work"`
	IssueWork          []models.IssueworkDTO          `json:"issue_work"`
	Article            []models.ArticleDTO            `json:"article"`
	BookshelfPublisher []models.BookshelfPublisherDTO `json:"bookshelf_publisher"`
	Book               []models.BookDTO               `json:"book"`
	Author             []models.AuthorDTO             `json:"author"`
	ArticleAuthor      []models.ArticleAuthorDTO      `json:"article_author"`
	BookAuthor         []models.BookAuthorDTO         `json:"book_author"`
	MediaArticle       []models.MediaArticleDTO       `json:"media_article"`
	MediaVideo         []models.MediaVideoDTO         `json:"media_video"`
	MediaLoFi          models.MediaLoFiDTOList        `json:"media_lofi"`
	MediaMusic         models.MediaMusicDTOList       `json:"media_music"`
	MediaFile          []models.MediaFileDTO          `json:"media_file"`
	MediaActor         []models.MediaActorDTO         `json:"media_actor"`
	MediaActorFile     []models.MediaActorFileDTO     `json:"media_actor_file"`
	Profile            models.ProfileDTOList          `json:"profile"`
	Permission         []models.PermissionDTO         `json:"permission"`
	Assignment         []models.AssignmentDTO         `json:"assignment"`
	Token              []models.TokenDTO              `json:"token"`
	MailAccount        []models.MailAccountDTO        `json:"mail_account"`
	Mail               []models.MailDTO               `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.TeamDTO
	Positions            []models.PositionDTO
	Roosters             []models.RoosterDTO
	Vendors              []models.VendorDTO
	Cardsets             []models.CardSetDTO
	Cards                []models.CardDTO
	Artists              []models.ArtistDTO
	Publishers           []models.PublisherDTO
	Worktypes            []models.WorkTypeDTO
	Comics               []models.ComicDTO
	Volumes              []models.VolumeDTO
	Storyarcs            []models.StoryArcDTO
	Issues               []models.IssueDTO
	Tradepaperbacks      []models.TradePaperbackDTO
	Comicworks           []models.ComicworkDTO
	Issueworks           []models.IssueworkDTO
	Articles             []models.ArticleDTO
	Bookshelf_publishers []models.BookshelfPublisherDTO
	Books                []models.BookDTO
	Authors              []models.AuthorDTO
	Article_authors      []models.ArticleAuthorDTO
	Book_authors         []models.BookAuthorDTO
	Mediaarticles        []models.MediaArticleDTO
	Mediavideos          []models.MediaVideoDTO
	Mediaactors          []models.MediaActorDTO
	Mediaactorfiles      []models.MediaActorFileDTO
	Mediafiles           []models.MediaFileDTO
	Medialofis           models.MediaLoFiDTOList
	MediaMusics          models.MediaMusicDTOList
	Profiles             models.ProfileDTOList
	Permissions          []models.PermissionDTO
	Assignments          []models.AssignmentDTO
	Tokens               []models.TokenDTO
	Mailaccounts         []models.MailAccountDTO
	Mail                 []models.MailDTO
)

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