package api

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

	"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"`
	MediaFile          []models.MediaFileDTO          `json:"media_file"`
	MediaActor         []models.MediaActorDTO         `json:"media_actor"`
	MediaActorFile     []models.MediaActorFileDTO     `json:"media_actor_file"`
	Profile            []models.ProfileDTO            `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
	Profiles             []models.ProfileDTO
	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

	_, err := client.R().
		SetBody(Login{
			Email:    "thomas.peetz@thpeetz.de",
			Password: "admin",
		}).
		SetHeader("Accept", "application/json").
		SetResult(&login).
		Post("http://127.0.0.1:8550/api/login")
	if err != nil {
		slog.Info("Health", "error", err.Error())
	}
	slog.Info("health", "token", login.Token)
	return login.Token
}

func GetData(server config.Server, apiVersion string) (data *ExportData, err error) {
	var login LoginResponse

	client := resty.New()
	client.SetLoggerWarnLevel(true)
	PostJSON(client, server, "api/login", &login)

	for path, value := range Registry {
		GetJSON(client, login.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,
		Profile:            Profiles,
		Permission:         Permissions,
		Assignment:         Assignments,
		Token:              Tokens,
		MailAccount:        Mailaccounts,
		Mail:               Mail,
	}
	defer client.Close()
	return &export, nil
}

func WriteJson(data *ExportData, fileName string) error {
	jsonData, err := json.MarshalIndent(data, "", "    ")
	if err != nil {
		slog.Info("JSON MarshalIndent failed", "Error:", err)
		return err
	}
	// Write bytes to file
	err = os.WriteFile(fileName, jsonData, 0644)
	if err != nil {
		slog.Info("Error writing file:", "Error", err)
		return err
	}
	return nil
}

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)
	}
	_, 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, path string, v any) {
	url := fmt.Sprintf("%s/%s", server.Url, path)
	if config.Verbose > 2 {
		slog.Info("PostJSON", "url", url)
	}
	_, err := client.R().
		SetBody(Login{
			Email:    server.Username,
			Password: server.Password,
		}).
		SetHeader("Accept", "application/json").
		SetResult(v).
		Post(url)
	if err != nil {
		slog.Info("PostJSON", "error", err.Error())
	}
	if config.Verbose > 2 {
		slog.Info(url, "token", v)
	}
}

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,
		"user/profiles":            &Profiles,
		"user/permissions":         &Permissions,
		"user/assignments":         &Assignments,
		"user/tokens":              &Tokens,
		"admin/mailaccounts":       &Mailaccounts,
		"user/mail":                &Mail,
	}
}