package subsonic

import (
	"context"
	"errors"
	"net/http"

	"github.com/jackc/pgx/v5"
	"github.com/jackc/pgx/v5/pgtype"

	"git.fabledsword.com/bvandeusen/minstrel/internal/db/dbq"
	"git.fabledsword.com/bvandeusen/minstrel/internal/playevents"
)

// handleStar implements /rest/star. Accepts any combination of id (track),
// albumId, artistId. All entities are validated before any insert; a single
// missing entity fails the whole call with Subsonic error 70.
func (m *mediaHandlers) handleStar(w http.ResponseWriter, r *http.Request) {
	user, ok := UserFromContext(r.Context())
	if !ok {
		WriteFail(w, r, ErrGeneric, "Unauthenticated")
		return
	}
	params := r.URL.Query()
	q := dbq.New(m.pool)
	trackID, err := resolveStarID(r.Context(), q, params.Get("id"), entityKindTrack)
	if err != nil {
		WriteFail(w, r, ErrDataNotFound, err.Error())
		return
	}
	albumID, err := resolveStarID(r.Context(), q, params.Get("albumId"), entityKindAlbum)
	if err != nil {
		WriteFail(w, r, ErrDataNotFound, err.Error())
		return
	}
	artistID, err := resolveStarID(r.Context(), q, params.Get("artistId"), entityKindArtist)
	if err != nil {
		WriteFail(w, r, ErrDataNotFound, err.Error())
		return
	}
	if trackID.Valid {
		rows, err := q.LikeTrack(r.Context(), dbq.LikeTrackParams{UserID: user.ID, TrackID: trackID})
		if err != nil {
			WriteFail(w, r, ErrGeneric, "Could not star track")
			return
		}
		if rows == 1 {
			_ = playevents.CaptureContextualLikeIfPlaying(r.Context(), q, user.ID, trackID, m.logger)
		}
	}
	if albumID.Valid {
		if err := q.LikeAlbum(r.Context(), dbq.LikeAlbumParams{UserID: user.ID, AlbumID: albumID}); err != nil {
			WriteFail(w, r, ErrGeneric, "Could not star album")
			return
		}
	}
	if artistID.Valid {
		if err := q.LikeArtist(r.Context(), dbq.LikeArtistParams{UserID: user.ID, ArtistID: artistID}); err != nil {
			WriteFail(w, r, ErrGeneric, "Could not star artist")
			return
		}
	}
	Write(w, r, struct{ Envelope }{Envelope: NewEnvelope("ok")})
}

// handleUnstar mirrors handleStar but DELETEs. Missing entities are treated
// as a no-op rather than an error — Subsonic clients commonly call unstar
// on entities the server has never seen (cross-server library moves).
func (m *mediaHandlers) handleUnstar(w http.ResponseWriter, r *http.Request) {
	user, ok := UserFromContext(r.Context())
	if !ok {
		WriteFail(w, r, ErrGeneric, "Unauthenticated")
		return
	}
	params := r.URL.Query()
	q := dbq.New(m.pool)
	if t, ok := parseUUID(params.Get("id")); ok {
		_ = q.UnlikeTrack(r.Context(), dbq.UnlikeTrackParams{UserID: user.ID, TrackID: t})
		_ = playevents.SoftDeleteContextualLikes(r.Context(), q, user.ID, t)
	}
	if a, ok := parseUUID(params.Get("albumId")); ok {
		_ = q.UnlikeAlbum(r.Context(), dbq.UnlikeAlbumParams{UserID: user.ID, AlbumID: a})
	}
	if a, ok := parseUUID(params.Get("artistId")); ok {
		_ = q.UnlikeArtist(r.Context(), dbq.UnlikeArtistParams{UserID: user.ID, ArtistID: a})
	}
	Write(w, r, struct{ Envelope }{Envelope: NewEnvelope("ok")})
}

type entityKind int

const (
	entityKindTrack entityKind = iota
	entityKindAlbum
	entityKindArtist
)

// resolveStarID returns (uuid, nil) if the param is empty (no-op), or
// (uuid, nil) if the entity exists, or (zero, error) if the entity is
// missing/malformed. Non-empty malformed UUID is treated as a 'not found'
// per Subsonic semantics.
func resolveStarID(ctx context.Context, q *dbq.Queries, raw string, kind entityKind) (pgtype.UUID, error) {
	if raw == "" {
		return pgtype.UUID{}, nil
	}
	id, ok := parseUUID(raw)
	if !ok {
		return pgtype.UUID{}, errors.New("not found")
	}
	switch kind {
	case entityKindTrack:
		if _, err := q.GetTrackByID(ctx, id); err != nil {
			if errors.Is(err, pgx.ErrNoRows) {
				return pgtype.UUID{}, errors.New("track not found")
			}
			return pgtype.UUID{}, err
		}
	case entityKindAlbum:
		if _, err := q.GetAlbumByID(ctx, id); err != nil {
			if errors.Is(err, pgx.ErrNoRows) {
				return pgtype.UUID{}, errors.New("album not found")
			}
			return pgtype.UUID{}, err
		}
	case entityKindArtist:
		if _, err := q.GetArtistByID(ctx, id); err != nil {
			if errors.Is(err, pgx.ErrNoRows) {
				return pgtype.UUID{}, errors.New("artist not found")
			}
			return pgtype.UUID{}, err
		}
	}
	return id, nil
}

func (m *mediaHandlers) handleGetStarred(w http.ResponseWriter, r *http.Request) {
	user, ok := UserFromContext(r.Context())
	if !ok {
		WriteFail(w, r, ErrGeneric, "Unauthenticated")
		return
	}
	q := dbq.New(m.pool)
	songs, albums, artists, err := loadStarred(r.Context(), q, user.ID)
	if err != nil {
		WriteFail(w, r, ErrGeneric, "Could not load starred")
		return
	}
	Write(w, r, GetStarredResponse{
		Envelope: NewEnvelope("ok"),
		Starred: GetStarredContainer{
			Artists: artists,
			Albums:  albums,
			Songs:   songs,
		},
	})
}

func (m *mediaHandlers) handleGetStarred2(w http.ResponseWriter, r *http.Request) {
	user, ok := UserFromContext(r.Context())
	if !ok {
		WriteFail(w, r, ErrGeneric, "Unauthenticated")
		return
	}
	q := dbq.New(m.pool)
	songs, albums, artists, err := loadStarred(r.Context(), q, user.ID)
	if err != nil {
		WriteFail(w, r, ErrGeneric, "Could not load starred")
		return
	}
	Write(w, r, GetStarred2Response{
		Envelope: NewEnvelope("ok"),
		Starred2: StarredContainer{
			Artists: artists,
			Albums:  albums,
			Songs:   songs,
		},
	})
}

// loadStarred fetches the user's full starred set in liked_at DESC order,
// projects to Subsonic refs (Song / Album / Artist).
func loadStarred(ctx context.Context, q *dbq.Queries, userID pgtype.UUID) ([]SongRef, []AlbumRef, []ArtistRef, error) {
	const cap = 500 // bounded for safety; M2 doesn't paginate getStarred
	songs := []SongRef{}
	albums := []AlbumRef{}
	artists := []ArtistRef{}

	trackRows, err := q.ListLikedTrackRows(ctx, dbq.ListLikedTrackRowsParams{
		UserID: userID, Limit: cap, Offset: 0,
	})
	if err != nil {
		return nil, nil, nil, err
	}
	for _, t := range trackRows {
		album, err := q.GetAlbumByID(ctx, t.AlbumID)
		if err != nil {
			return nil, nil, nil, err
		}
		artist, err := q.GetArtistByID(ctx, t.ArtistID)
		if err != nil {
			return nil, nil, nil, err
		}
		songs = append(songs, songRef(t, album.Title, artist.Name))
	}

	albumRows, err := q.ListLikedAlbumRows(ctx, dbq.ListLikedAlbumRowsParams{
		UserID: userID, Limit: cap, Offset: 0,
	})
	if err != nil {
		return nil, nil, nil, err
	}
	for _, a := range albumRows {
		artist, err := q.GetArtistByID(ctx, a.ArtistID)
		if err != nil {
			return nil, nil, nil, err
		}
		count, err := q.CountTracksByAlbum(ctx, a.ID)
		if err != nil {
			return nil, nil, nil, err
		}
		albums = append(albums, albumRef(a, artist.Name, int(count), 0))
	}

	artistRows, err := q.ListLikedArtistRows(ctx, dbq.ListLikedArtistRowsParams{
		UserID: userID, Limit: cap, Offset: 0,
	})
	if err != nil {
		return nil, nil, nil, err
	}
	for _, a := range artistRows {
		albums, err := q.ListAlbumsByArtist(ctx, a.ID)
		if err != nil {
			return nil, nil, nil, err
		}
		artists = append(artists, artistRef(a, len(albums)))
	}

	return songs, albums, artists, nil
}
