package app

import (
	"fmt"
	"net/http"
	"strconv"
	"time"
)

type CreatorDetails struct {
	UserID             int64
	Character          CharacterRecord
	CharacterName      string
	CharacterAvatarURL string
	DisplayName        string
}

func fetchCreatorDetails(createdBy string) CreatorDetails {
	userID := getRecordUserID(createdBy)
	character, _ := fetchMainCharacterRecordByUserID(db, userID)
	characterName := getCharacterFullName(character)
	characterAvatar := getCharacterAvatarURL(character.ID)
	displayName := fmt.Sprintf("User%d", userID)
	if userID == 0 {
		displayName = "(anonymous)"
	}
	if character.ID > 0 {
		displayName = characterName
	}
	return CreatorDetails{
		UserID:             userID,
		Character:          character,
		CharacterName:      characterName,
		CharacterAvatarURL: characterAvatar,
		DisplayName:        displayName,
	}
}

type RecordDetails struct {
	ID             int64
	Name           string
	CreatedAt      time.Time
	CreatedAtHuman string
	UpdatedAt      time.Time
	UpdatedAtHuman string
	Creator        CreatorDetails
}

func fetchRecordDetails(recordType any, ID int64) (RecordDetails, error) {
	switch recordType.(type) {
	case DocumentRecord:
		record, err := fetchDocumentRecordByID(db, ID)
		if err != nil {
			return RecordDetails{}, err
		}
		return RecordDetails{
			ID:             ID,
			Name:           record.Title,
			CreatedAt:      record.CreatedAt,
			CreatedAtHuman: formatHumanTime(record.CreatedAt),
			UpdatedAt:      record.UpdatedAt,
			UpdatedAtHuman: formatHumanTime(record.UpdatedAt),
			Creator:        fetchCreatorDetails(record.CreatedBy),
		}, nil

	case CharacterRecord:
		record, err := fetchCharacterRecordByID(db, ID)
		if err != nil {
			return RecordDetails{}, err
		}
		return RecordDetails{
			ID:             ID,
			Name:           getCharacterFullName(record),
			CreatedAt:      record.CreatedAt,
			CreatedAtHuman: formatHumanTime(record.CreatedAt),
			UpdatedAt:      record.UpdatedAt,
			UpdatedAtHuman: formatHumanTime(record.UpdatedAt),
			Creator:        fetchCreatorDetails(fmt.Sprintf("user:%d", record.UserID)),
		}, nil

	case StrategyBoardRecord:
		record, err := fetchStrategyBoardRecordByID(db, ID)
		if err != nil {
			return RecordDetails{}, err
		}
		return RecordDetails{
			ID:             ID,
			Name:           record.Name,
			CreatedAt:      record.CreatedAt,
			CreatedAtHuman: formatHumanTime(record.CreatedAt),
			UpdatedAt:      record.CreatedAt,
			UpdatedAtHuman: formatHumanTime(record.CreatedAt),
			Creator:        fetchCreatorDetails(record.CreatedBy),
		}, nil

	case UserRecord:
		record, err := fetchUserRecordByID(db, ID)
		if err != nil {
			return RecordDetails{}, err
		}
		creatorDetails := fetchCreatorDetails(fmt.Sprintf("user:%d", record.ID))
		return RecordDetails{
			ID:        ID,
			Name:      creatorDetails.DisplayName,
			CreatedAt: record.CreatedAt,
			UpdatedAt: record.CreatedAt,
			Creator:   creatorDetails,
		}, nil

	}
	return RecordDetails{}, errHttpNotFound
}

func getRecordInfo(recordID int64, creatorID int64, updatedAt time.Time, options [][]string) map[string]any {
	characterName := ""
	characterAvatar := ""
	var character CharacterRecord
	if creatorID > 0 {
		character, _ = fetchMainCharacterRecordByUserID(db, creatorID)
		if character.ID > 0 {
			characterName = getCharacterFullName(character)
			characterAvatar = getCharacterAvatarURL(character.ID)
		}
	}
	return map[string]any{
		"ID":              recordID,
		"characterName":   characterName,
		"characterAvatar": characterAvatar,
		"character":       character,
		"updatedAt":       formatHumanTime(updatedAt),
		"options":         options,
	}
}

func deleteRecord(recordType any, ID int64) error {
	switch recordType.(type) {
	case DocumentRecord:
		return deleteDocumentRecord(db, ID)
	case CharacterRecord:
		return deleteCharacterRecord(db, ID)
	}
	return errHttpNotFound
}

/* Render page with delete confirmation, when submitted deletes the record */
func httpHandleRecordDelete(w http.ResponseWriter, r *http.Request, recordType any, recordID int64) {

	details, err := fetchRecordDetails(recordType, recordID)
	if err != nil {
		httpHandleError(w, err)
		return
	}

	if r.Method == "POST" {
		if err := r.ParseForm(); err != nil {
			httpHandleError(w, err)
			return
		}
		formID, _ := strconv.ParseInt(r.Form.Get("id"), 10, 64)
		if r.Form.Get("confirm") == "Confirm" && formID == recordID {
			if err := deleteRecord(recordType, recordID); err != nil {
				httpHandleError(w, err)
				return
			}
			http.Redirect(w, r, "/user", http.StatusFound)
			return
		}
	}

	httpHandleTemplate(w, "delete.html", map[string]any{
		"id":   recordID,
		"name": details.Name,
	})
}