package repository

import (
	"butterfliu/internal/model"
	"database/sql"
)

type ExistingMediaFile struct {
	Path        string
	MediaFileID int
	HasSong     bool
}

type MediaRepository struct {
	db *sql.DB
}

func NewMediaRepository(db *sql.DB) *MediaRepository {
	return &MediaRepository{db: db}
}

func (r *MediaRepository) Get(id int) (model.MediaFile, error) {
	var m model.MediaFile
	err := r.db.QueryRow("SELECT id, path, library_id FROM media_files WHERE id = ?", id).Scan(
		&m.ID, &m.Path, &m.LibraryID,
	)
	if err != nil {
		return model.MediaFile{}, err
	}
	return m, nil
}

func (r *MediaRepository) GetByPath(path string) (model.MediaFile, error) {
	row := r.db.QueryRow(`
		SELECT id, path, library_id,
		       COALESCE(file_size, 0), COALESCE(format, ''),
		       COALESCE(bit_rate, 0), COALESCE(sample_rate, 0),
		       COALESCE(created_at, '1970-01-01T00:00:00Z'),
		       COALESCE(updated_at, '1970-01-01T00:00:00Z')
		FROM media_files WHERE path = ?
	`)
	var mediaFile model.MediaFile
	if err := row.Scan(
		&mediaFile.ID, &mediaFile.Path, &mediaFile.LibraryID,
		&mediaFile.FileSize, &mediaFile.Format,
		&mediaFile.BitRate, &mediaFile.SampleRate,
		&mediaFile.CreatedAt, &mediaFile.UpdatedAt,
	); err != nil {
		return model.MediaFile{}, err
	}
	return mediaFile, nil
}

func (r *MediaRepository) Create(path string, libraryID int) (model.MediaFile, error) {
	result, err := r.db.Exec("INSERT INTO media_files (path, library_id) VALUES (?, ?)", path, libraryID)
	if err != nil {
		return model.MediaFile{}, err
	}

	id, err := result.LastInsertId()
	if err != nil {
		return model.MediaFile{}, err
	}

	return model.MediaFile{
		ID:        int(id),
		Path:      path,
		LibraryID: libraryID,
	}, nil
}

func (r *MediaRepository) ListExistingByLibrary(libraryID int) ([]ExistingMediaFile, error) {
	rows, err := r.db.Query(`
		SELECT mf.path, mf.id, CASE WHEN s.id IS NULL THEN 0 ELSE 1 END AS has_song
		FROM media_files mf
		LEFT JOIN songs s ON s.media_file_id = mf.id
		WHERE mf.library_id = ?
	`, libraryID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()

	existing := []ExistingMediaFile{}
	for rows.Next() {
		var item ExistingMediaFile
		var hasSong int
		if err := rows.Scan(&item.Path, &item.MediaFileID, &hasSong); err != nil {
			return nil, err
		}
		item.HasSong = hasSong == 1
		existing = append(existing, item)
	}
	return existing, nil
}

func (r *MediaRepository) GetSongsByLibraryWithDetails(libraryID int) ([]model.SongDetail, error) {
	rows, err := r.db.Query(`
		SELECT s.id, s.title, a.name as artist_name, al.title as album_title, s.duration, mf.path
		FROM songs s
		INNER JOIN media_files mf ON s.media_file_id = mf.id
		INNER JOIN artists a ON s.artist_id = a.id
		INNER JOIN albums al ON s.album_id = al.id
		WHERE mf.library_id = ?
		ORDER BY s.title
	`, libraryID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()

	songs := []model.SongDetail{}
	for rows.Next() {
		var song model.SongDetail
		if err := rows.Scan(&song.ID, &song.Title, &song.Artist, &song.Album, &song.Duration, &song.Path); err != nil {
			return nil, err
		}
		songs = append(songs, song)
	}
	return songs, nil
}

func (r *MediaRepository) GetSongsByArtistWithDetails(artistID int) ([]model.SongDetail, error) {
	rows, err := r.db.Query(`
		SELECT s.id, s.title, a.name as artist_name, al.title as album_title, s.duration, mf.path
		FROM songs s
		INNER JOIN media_files mf ON s.media_file_id = mf.id
		INNER JOIN artists a ON s.artist_id = a.id
		INNER JOIN albums al ON s.album_id = al.id
		WHERE s.artist_id = ?
		ORDER BY s.title
	`, artistID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()

	songs := []model.SongDetail{}
	for rows.Next() {
		var song model.SongDetail
		if err := rows.Scan(&song.ID, &song.Title, &song.Artist, &song.Album, &song.Duration, &song.Path); err != nil {
			return nil, err
		}
		songs = append(songs, song)
	}
	return songs, nil
}

func (r *MediaRepository) GetSongsByAlbumWithDetails(albumID int) ([]model.SongDetail, error) {
	rows, err := r.db.Query(`
		SELECT s.id, s.title, a.name as artist_name, al.title as album_title, s.duration, mf.path
		FROM songs s
		INNER JOIN media_files mf ON s.media_file_id = mf.id
		INNER JOIN artists a ON s.artist_id = a.id
		INNER JOIN albums al ON s.album_id = al.id
		WHERE s.album_id = ?
		ORDER BY s.title
	`, albumID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()

	songs := []model.SongDetail{}
	for rows.Next() {
		var song model.SongDetail
		if err := rows.Scan(&song.ID, &song.Title, &song.Artist, &song.Album, &song.Duration, &song.Path); err != nil {
			return nil, err
		}
		songs = append(songs, song)
	}
	return songs, nil
}