package summary

import (
	"fmt"
	"seanime/internal/api/anilist"
	"seanime/internal/library/anime"
	"time"

	"github.com/google/uuid"
)

const (
	LogFileNotMatched LogType = iota
	LogComparison
	LogSuccessfullyMatched
	LogFailedMatch
	LogMatchValidated
	LogUnmatched
	LogMetadataMediaTreeFetched
	LogMetadataMediaTreeFetchFailed
	LogMetadataEpisodeNormalized
	LogMetadataEpisodeNormalizationFailed
	LogMetadataEpisodeZero
	LogMetadataNC
	LogMetadataSpecial
	LogMetadataMain
	LogMetadataHydrated
	LogPanic
	LogDebug
)

type (
	LogType int

	ScanSummaryLogger struct {
		Logs            []*ScanSummaryLog
		LocalFiles      []*anime.LocalFile
		AllMedia        []*anime.NormalizedMedia
		AnimeCollection *anilist.AnimeCollectionWithRelations
	}

	ScanSummaryLog struct { // Holds a log entry. The log entry will then be used to generate a ScanSummary.
		ID       string `json:"id"`
		FilePath string `json:"filePath"`
		Level    string `json:"level"`
		Message  string `json:"message"`
	}

	ScanSummary struct {
		ID             string              `json:"id"`
		Groups         []*ScanSummaryGroup `json:"groups"`
		UnmatchedFiles []*ScanSummaryFile  `json:"unmatchedFiles"`
	}

	ScanSummaryFile struct {
		ID        string            `json:"id"`
		LocalFile *anime.LocalFile  `json:"localFile"`
		Logs      []*ScanSummaryLog `json:"logs"`
	}

	ScanSummaryGroup struct {
		ID                  string             `json:"id"`
		Files               []*ScanSummaryFile `json:"files"`
		MediaId             int                `json:"mediaId"`
		MediaTitle          string             `json:"mediaTitle"`
		MediaImage          string             `json:"mediaImage"`
		MediaIsInCollection bool               `json:"mediaIsInCollection"` // Whether the media is in the user's AniList collection
	}

	ScanSummaryItem struct { // Database item
		CreatedAt   time.Time    `json:"createdAt"`
		ScanSummary *ScanSummary `json:"scanSummary"`
	}
)

func NewScanSummaryLogger() *ScanSummaryLogger {
	return &ScanSummaryLogger{
		Logs: make([]*ScanSummaryLog, 0),
	}
}

// HydrateData will hydrate the data needed to generate the summary.
func (l *ScanSummaryLogger) HydrateData(lfs []*anime.LocalFile, media []*anime.NormalizedMedia, animeCollection *anilist.AnimeCollectionWithRelations) {
	l.LocalFiles = lfs
	l.AllMedia = media
	l.AnimeCollection = animeCollection
}

func (l *ScanSummaryLogger) GenerateSummary() *ScanSummary {
	if l == nil || l.LocalFiles == nil || l.AllMedia == nil || l.AnimeCollection == nil {
		return nil
	}
	summary := &ScanSummary{
		ID:             uuid.NewString(),
		Groups:         make([]*ScanSummaryGroup, 0),
		UnmatchedFiles: make([]*ScanSummaryFile, 0),
	}

	groupsMap := make(map[int][]*ScanSummaryFile)

	// Generate summary files
	for _, lf := range l.LocalFiles {

		if lf.MediaId == 0 {
			summary.UnmatchedFiles = append(summary.UnmatchedFiles, &ScanSummaryFile{
				ID:        uuid.NewString(),
				LocalFile: lf,
				Logs:      l.getFileLogs(lf),
			})
			continue
		}

		summaryFile := &ScanSummaryFile{
			ID:        uuid.NewString(),
			LocalFile: lf,
			Logs:      l.getFileLogs(lf),
		}

		//summary.Files = append(summary.Files, summaryFile)

		// Add to group
		if _, ok := groupsMap[lf.MediaId]; !ok {
			groupsMap[lf.MediaId] = make([]*ScanSummaryFile, 0)
			groupsMap[lf.MediaId] = append(groupsMap[lf.MediaId], summaryFile)
		} else {
			groupsMap[lf.MediaId] = append(groupsMap[lf.MediaId], summaryFile)
		}
	}

	// Generate summary groups
	for mediaId, files := range groupsMap {
		mediaTitle := ""
		mediaImage := ""
		mediaIsInCollection := false
		for _, m := range l.AllMedia {
			if m.ID == mediaId {
				mediaTitle = m.GetPreferredTitle()
				mediaImage = ""
				if m.GetCoverImage() != nil && m.GetCoverImage().GetLarge() != nil {
					mediaImage = *m.GetCoverImage().GetLarge()
				}
				break
			}
		}
		if _, found := l.AnimeCollection.GetListEntryFromMediaId(mediaId); found {
			mediaIsInCollection = true
		}

		summary.Groups = append(summary.Groups, &ScanSummaryGroup{
			ID:                  uuid.NewString(),
			Files:               files,
			MediaId:             mediaId,
			MediaTitle:          mediaTitle,
			MediaImage:          mediaImage,
			MediaIsInCollection: mediaIsInCollection,
		})
	}

	return summary
}

func (l *ScanSummaryLogger) LogComparison(lf *anime.LocalFile, algo string, bestTitle string, ratingType string, rating string) {
	if l == nil {
		return
	}

	msg := fmt.Sprintf("Comparison using %s. Best title: \"%s\". %s: %s", algo, bestTitle, ratingType, rating)
	l.logType(LogComparison, lf, msg)
}

func (l *ScanSummaryLogger) LogSuccessfullyMatched(lf *anime.LocalFile, mediaId int) {
	if l == nil {
		return
	}
	msg := fmt.Sprintf("Successfully matched to media %d", mediaId)
	l.logType(LogSuccessfullyMatched, lf, msg)
}

func (l *ScanSummaryLogger) LogPanic(lf *anime.LocalFile, stackTrace string) {
	if l == nil {
		return
	}
	//msg := fmt.Sprintf("Panic occurred, please report this issue on the GitHub repository with the stack trace printed in the terminal")
	l.logType(LogPanic, lf, "PANIC! "+stackTrace)
}

func (l *ScanSummaryLogger) LogFailedMatch(lf *anime.LocalFile, reason string) {
	if l == nil {
		return
	}
	msg := fmt.Sprintf("Failed to match: %s", reason)
	l.logType(LogFailedMatch, lf, msg)
}

func (l *ScanSummaryLogger) LogMatchValidated(lf *anime.LocalFile, mediaId int) {
	if l == nil {
		return
	}
	msg := fmt.Sprintf("Match validated for media %d", mediaId)
	l.logType(LogMatchValidated, lf, msg)
}

func (l *ScanSummaryLogger) LogUnmatched(lf *anime.LocalFile, reason string) {
	if l == nil {
		return
	}
	msg := fmt.Sprintf("Unmatched: %s", reason)
	l.logType(LogUnmatched, lf, msg)
}

func (l *ScanSummaryLogger) LogFileNotMatched(lf *anime.LocalFile, reason string) {
	if l == nil {
		return
	}
	msg := fmt.Sprintf("Not matched: %s", reason)
	l.logType(LogFileNotMatched, lf, msg)
}

func (l *ScanSummaryLogger) LogMetadataMediaTreeFetched(lf *anime.LocalFile, ms int64, branches int) {
	if l == nil {
		return
	}
	msg := fmt.Sprintf("Media tree fetched in %dms. Branches: %d", ms, branches)
	l.logType(LogMetadataMediaTreeFetched, lf, msg)
}

func (l *ScanSummaryLogger) LogMetadataMediaTreeFetchFailed(lf *anime.LocalFile, err error, ms int64) {
	if l == nil {
		return
	}
	msg := fmt.Sprintf("Could not fetch media tree: %s. Took %dms", err.Error(), ms)
	l.logType(LogMetadataMediaTreeFetchFailed, lf, msg)
}

func (l *ScanSummaryLogger) LogMetadataEpisodeNormalized(lf *anime.LocalFile, mediaId int, episode int, newEpisode int, newMediaId int, aniDBEpisode string) {
	if l == nil {
		return
	}
	msg := fmt.Sprintf("Episode %d normalized to %d. New media ID: %d. AniDB episode: %s", episode, newEpisode, newMediaId, aniDBEpisode)
	l.logType(LogMetadataEpisodeNormalized, lf, msg)
}

func (l *ScanSummaryLogger) LogMetadataEpisodeNormalizationFailed(lf *anime.LocalFile, err error, episode int, aniDBEpisode string) {
	if l == nil {
		return
	}
	msg := fmt.Sprintf("Episode normalization failed. Reason \"%s\". Episode %d. AniDB episode %s", err.Error(), episode, aniDBEpisode)
	l.logType(LogMetadataEpisodeNormalizationFailed, lf, msg)
}

func (l *ScanSummaryLogger) LogMetadataNC(lf *anime.LocalFile) {
	if l == nil {
		return
	}
	msg := fmt.Sprintf("Marked as NC file")
	l.logType(LogMetadataNC, lf, msg)
}

func (l *ScanSummaryLogger) LogMetadataSpecial(lf *anime.LocalFile, episode int, aniDBEpisode string) {
	if l == nil {
		return
	}
	msg := fmt.Sprintf("Marked as Special episode. Episode %d. AniDB episode: %s", episode, aniDBEpisode)
	l.logType(LogMetadataSpecial, lf, msg)
}

func (l *ScanSummaryLogger) LogMetadataMain(lf *anime.LocalFile, episode int, aniDBEpisode string) {
	if l == nil {
		return
	}
	msg := fmt.Sprintf("Marked as main episode. Episode %d. AniDB episode: %s", episode, aniDBEpisode)
	l.logType(LogMetadataMain, lf, msg)
}

func (l *ScanSummaryLogger) LogMetadataEpisodeZero(lf *anime.LocalFile, episode int, aniDBEpisode string) {
	if l == nil {
		return
	}
	msg := fmt.Sprintf("Marked as main episode. Episode %d. AniDB episode set to %s assuming AniDB does not include episode 0 in the episode count.", episode, aniDBEpisode)
	l.logType(LogMetadataEpisodeZero, lf, msg)
}

func (l *ScanSummaryLogger) LogMetadataHydrated(lf *anime.LocalFile, mediaId int) {
	if l == nil {
		return
	}
	msg := fmt.Sprintf("Metadata hydrated for media %d", mediaId)
	l.logType(LogMetadataHydrated, lf, msg)
}

func (l *ScanSummaryLogger) LogDebug(lf *anime.LocalFile, message string) {
	if l == nil {
		return
	}
	l.log(lf, "info", message)
}

func (l *ScanSummaryLogger) logType(logType LogType, lf *anime.LocalFile, message string) {
	if l == nil {
		return
	}
	switch logType {
	case LogComparison:
		l.log(lf, "info", message)
	case LogSuccessfullyMatched:
		l.log(lf, "info", message)
	case LogFailedMatch:
		l.log(lf, "warning", message)
	case LogMatchValidated:
		l.log(lf, "info", message)
	case LogUnmatched:
		l.log(lf, "warning", message)
	case LogMetadataMediaTreeFetched:
		l.log(lf, "info", message)
	case LogMetadataMediaTreeFetchFailed:
		l.log(lf, "error", message)
	case LogMetadataEpisodeNormalized:
		l.log(lf, "info", message)
	case LogMetadataEpisodeNormalizationFailed:
		l.log(lf, "error", message)
	case LogMetadataHydrated:
		l.log(lf, "info", message)
	case LogMetadataNC:
		l.log(lf, "info", message)
	case LogMetadataSpecial:
		l.log(lf, "info", message)
	case LogMetadataMain:
		l.log(lf, "info", message)
	case LogMetadataEpisodeZero:
		l.log(lf, "warning", message)
	case LogFileNotMatched:
		l.log(lf, "warning", message)
	case LogPanic:
		l.log(lf, "error", message)
	case LogDebug:
		l.log(lf, "info", message)
	}
}

func (l *ScanSummaryLogger) log(lf *anime.LocalFile, level string, message string) {
	if l == nil {
		return
	}
	l.Logs = append(l.Logs, &ScanSummaryLog{
		ID:       uuid.NewString(),
		FilePath: lf.Path,
		Level:    level,
		Message:  message,
	})
}

func (l *ScanSummaryLogger) getFileLogs(lf *anime.LocalFile) []*ScanSummaryLog {
	logs := make([]*ScanSummaryLog, 0)
	if l == nil {
		return logs
	}
	for _, log := range l.Logs {
		if lf.HasSamePath(log.FilePath) {
			logs = append(logs, log)
		}
	}
	return logs
}