package backend

import (
	"encoding/base64"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"os"
	"path/filepath"
	"regexp"
	"strings"
	"time"
)

type DeezerDownloader struct {
	client *http.Client
}

type DeezerTrack struct {
	ID          int64  `json:"id"`
	Title       string `json:"title"`
	TitleShort  string `json:"title_short"`
	Duration    int    `json:"duration"`
	TrackPos    int    `json:"track_position"`
	DiskNumber  int    `json:"disk_number"`
	ISRC        string `json:"isrc"`
	ReleaseDate string `json:"release_date"`
	Artist      struct {
		Name string `json:"name"`
		ID   int64  `json:"id"`
	} `json:"artist"`
	Album struct {
		Title    string `json:"title"`
		ID       int64  `json:"id"`
		CoverXL  string `json:"cover_xl"`
		CoverBig string `json:"cover_big"`
	} `json:"album"`
	Contributors []struct {
		Name string `json:"name"`
		Role string `json:"role"`
	} `json:"contributors"`
}

type DeezMateResponse struct {
	Success bool `json:"success"`
	Links   struct {
		FLAC string `json:"flac"`
	} `json:"links"`
}

func NewDeezerDownloader() *DeezerDownloader {
	return &DeezerDownloader{
		client: &http.Client{
			Timeout: 60 * time.Second,
		},
	}
}

func (d *DeezerDownloader) GetDeezerURLFromSpotify(spotifyTrackID string) (string, error) {
	// Decode base64 API URL
	spotifyBase, _ := base64.StdEncoding.DecodeString("aHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLw==")
	spotifyURL := fmt.Sprintf("%s%s", string(spotifyBase), spotifyTrackID)

	apiBase, _ := base64.StdEncoding.DecodeString("aHR0cHM6Ly9hcGkuc29uZy5saW5rL3YxLWFscGhhLjEvbGlua3M/dXJsPQ==")
	apiURL := fmt.Sprintf("%s%s", string(apiBase), spotifyURL)

	req, err := http.NewRequest("GET", apiURL, nil)
	if err != nil {
		return "", fmt.Errorf("failed to create request: %w", err)
	}

	fmt.Println("Getting Deezer URL...")

	resp, err := d.client.Do(req)
	if err != nil {
		return "", fmt.Errorf("failed to get Deezer URL: %w", err)
	}
	defer resp.Body.Close()

	if resp.StatusCode != 200 {
		return "", fmt.Errorf("API returned status %d", resp.StatusCode)
	}

	// Read body first to handle encoding issues
	body, err := io.ReadAll(resp.Body)
	if err != nil {
		return "", fmt.Errorf("failed to read response body: %w", err)
	}

	if len(body) == 0 {
		return "", fmt.Errorf("API returned empty response")
	}

	var songLinkResp struct {
		LinksByPlatform map[string]struct {
			URL string `json:"url"`
		} `json:"linksByPlatform"`
	}
	if err := json.Unmarshal(body, &songLinkResp); err != nil {
		// Truncate body for error message (max 200 chars)
		bodyStr := string(body)
		if len(bodyStr) > 200 {
			bodyStr = bodyStr[:200] + "..."
		}
		return "", fmt.Errorf("failed to decode response: %w (response: %s)", err, bodyStr)
	}

	deezerLink, ok := songLinkResp.LinksByPlatform["deezer"]
	if !ok || deezerLink.URL == "" {
		return "", fmt.Errorf("deezer link not found")
	}

	deezerURL := deezerLink.URL
	fmt.Printf("Found Deezer URL: %s\n", deezerURL)
	return deezerURL, nil
}

func (d *DeezerDownloader) GetTrackIDFromURL(deezerURL string) (int64, error) {
	// Extract track ID from Deezer URL
	// Format: https://www.deezer.com/track/3412534581
	parts := strings.Split(deezerURL, "/track/")
	if len(parts) < 2 {
		return 0, fmt.Errorf("invalid Deezer URL format")
	}

	// Get the track ID part and remove any query parameters
	trackIDStr := strings.Split(parts[1], "?")[0]
	trackIDStr = strings.TrimSpace(trackIDStr)

	var trackID int64
	_, err := fmt.Sscanf(trackIDStr, "%d", &trackID)
	if err != nil {
		return 0, fmt.Errorf("failed to parse track ID: %w", err)
	}

	return trackID, nil
}

func (d *DeezerDownloader) GetTrackByID(trackID int64) (*DeezerTrack, error) {
	// Decode base64 API URL
	apiBase, _ := base64.StdEncoding.DecodeString("aHR0cHM6Ly9hcGkuZGVlemVyLmNvbS8yLjAvdHJhY2sv")
	url := fmt.Sprintf("%s%d", string(apiBase), trackID)

	resp, err := d.client.Get(url)
	if err != nil {
		return nil, fmt.Errorf("failed to fetch track: %w", err)
	}
	defer resp.Body.Close()

	if resp.StatusCode != 200 {
		body, _ := io.ReadAll(resp.Body)
		return nil, fmt.Errorf("API returned status %d: %s", resp.StatusCode, string(body))
	}

	// Read body first to handle encoding issues and provide better error messages
	body, err := io.ReadAll(resp.Body)
	if err != nil {
		return nil, fmt.Errorf("failed to read response body: %w", err)
	}

	if len(body) == 0 {
		return nil, fmt.Errorf("API returned empty response")
	}

	var track DeezerTrack
	if err := json.Unmarshal(body, &track); err != nil {
		// Truncate body for error message (max 200 chars)
		bodyStr := string(body)
		if len(bodyStr) > 200 {
			bodyStr = bodyStr[:200] + "..."
		}
		return nil, fmt.Errorf("failed to decode response: %w (response: %s)", err, bodyStr)
	}

	if track.ID == 0 {
		return nil, fmt.Errorf("track not found")
	}

	return &track, nil
}

func (d *DeezerDownloader) GetDownloadURL(trackID int64) (string, error) {
	// Decode base64 API URL
	apiBase, _ := base64.StdEncoding.DecodeString("aHR0cHM6Ly9hcGkuZGVlem1hdGUuY29tL2RsLw==")
	url := fmt.Sprintf("%s%d", string(apiBase), trackID)

	resp, err := d.client.Get(url)
	if err != nil {
		return "", fmt.Errorf("failed to get download URL: %w", err)
	}
	defer resp.Body.Close()

	// Read body first to handle encoding issues and provide better error messages
	body, err := io.ReadAll(resp.Body)
	if err != nil {
		return "", fmt.Errorf("failed to read response body: %w", err)
	}

	if len(body) == 0 {
		return "", fmt.Errorf("API returned empty response")
	}

	var apiResp DeezMateResponse
	if err := json.Unmarshal(body, &apiResp); err != nil {
		// Truncate body for error message (max 200 chars)
		bodyStr := string(body)
		if len(bodyStr) > 200 {
			bodyStr = bodyStr[:200] + "..."
		}
		return "", fmt.Errorf("failed to decode API response: %w (response: %s)", err, bodyStr)
	}

	if !apiResp.Success || apiResp.Links.FLAC == "" {
		return "", fmt.Errorf("no FLAC download link available")
	}

	return apiResp.Links.FLAC, nil
}

func (d *DeezerDownloader) DownloadFile(url, filepath string) error {
	// Use a separate client with a longer timeout. The default client's 60s limit
	// causes downloads to fail on slow connections or for large Hi-Res files.
	downloadClient := &http.Client{
		Timeout: 5 * time.Minute, // 5 minutes for large files
	}

	resp, err := downloadClient.Get(url)
	if err != nil {
		return fmt.Errorf("failed to download file: %w", err)
	}
	defer resp.Body.Close()

	if resp.StatusCode != 200 {
		return fmt.Errorf("download failed with status %d", resp.StatusCode)
	}

	out, err := os.Create(filepath)
	if err != nil {
		return fmt.Errorf("failed to create file: %w", err)
	}
	defer out.Close()

	fmt.Println("Downloading...")
	// Use progress writer to track download
	pw := NewProgressWriter(out)
	_, err = io.Copy(pw, resp.Body)
	if err != nil {
		return fmt.Errorf("failed to write file: %w", err)
	}

	// Print final size
	fmt.Printf("\rDownloaded: %.2f MB (Complete)\n", float64(pw.GetTotal())/(1024*1024))
	return nil
}

func (d *DeezerDownloader) DownloadCoverArt(coverURL, filepath string) error {
	if coverURL == "" {
		return fmt.Errorf("no cover URL provided")
	}

	resp, err := d.client.Get(coverURL)
	if err != nil {
		return fmt.Errorf("failed to download cover: %w", err)
	}
	defer resp.Body.Close()

	if resp.StatusCode != 200 {
		return fmt.Errorf("cover download failed with status %d", resp.StatusCode)
	}

	out, err := os.Create(filepath)
	if err != nil {
		return fmt.Errorf("failed to create cover file: %w", err)
	}
	defer out.Close()

	_, err = io.Copy(out, resp.Body)
	return err
}

func buildFilename(title, artist string, trackNumber int, format string, includeTrackNumber bool, position int, useAlbumTrackNumber bool) string {
	var filename string

	// Determine track number to use
	numberToUse := position
	if useAlbumTrackNumber && trackNumber > 0 {
		numberToUse = trackNumber
	}

	// Check if format is a template (contains {})
	if strings.Contains(format, "{") {
		filename = format
		filename = strings.ReplaceAll(filename, "{title}", title)
		filename = strings.ReplaceAll(filename, "{artist}", artist)

		// Handle track number - if numberToUse is 0, remove {track} and surrounding separators
		if numberToUse > 0 {
			filename = strings.ReplaceAll(filename, "{track}", fmt.Sprintf("%02d", numberToUse))
		} else {
			// Remove {track} with common separators
			filename = regexp.MustCompile(`\{track\}\.\s*`).ReplaceAllString(filename, "")
			filename = regexp.MustCompile(`\{track\}\s*-\s*`).ReplaceAllString(filename, "")
			filename = regexp.MustCompile(`\{track\}\s*`).ReplaceAllString(filename, "")
		}
	} else {
		// Legacy format support
		switch format {
		case "artist-title":
			filename = fmt.Sprintf("%s - %s", artist, title)
		case "title":
			filename = title
		default: // "title-artist"
			filename = fmt.Sprintf("%s - %s", title, artist)
		}

		// Add track number prefix if enabled (legacy behavior)
		if includeTrackNumber && position > 0 {
			filename = fmt.Sprintf("%02d. %s", numberToUse, filename)
		}
	}

	return filename + ".flac"
}

func (d *DeezerDownloader) DownloadByURL(deezerURL, outputDir, filenameFormat string, includeTrackNumber bool, position int, spotifyTrackName, spotifyArtistName, spotifyAlbumName string, useAlbumTrackNumber bool) (string, error) {
	fmt.Printf("Using Deezer URL: %s\n", deezerURL)

	// Extract track ID from URL
	trackID, err := d.GetTrackIDFromURL(deezerURL)
	if err != nil {
		return "", err
	}

	// Get track info by ID
	track, err := d.GetTrackByID(trackID)
	if err != nil {
		return "", err
	}

	// Use Spotify metadata if provided, otherwise fallback to Deezer metadata
	artists := spotifyArtistName
	trackTitle := spotifyTrackName
	albumTitle := spotifyAlbumName

	if artists == "" {
		artists = track.Artist.Name
		if len(track.Contributors) > 0 {
			var mainArtists []string
			for _, contrib := range track.Contributors {
				if contrib.Role == "Main" {
					mainArtists = append(mainArtists, contrib.Name)
				}
			}
			if len(mainArtists) > 0 {
				artists = strings.Join(mainArtists, ", ")
			}
		}
	}

	if trackTitle == "" {
		trackTitle = track.Title
	}

	if albumTitle == "" {
		albumTitle = track.Album.Title
	}

	fmt.Printf("Found track: %s - %s\n", artists, trackTitle)
	fmt.Printf("Album: %s\n", albumTitle)

	downloadURL, err := d.GetDownloadURL(track.ID)
	if err != nil {
		return "", err
	}

	safeArtist := sanitizeFilename(artists)
	safeTitle := sanitizeFilename(trackTitle)

	// Check if file with same ISRC already exists
	if existingFile, exists := CheckISRCExists(outputDir, track.ISRC); exists {
		fmt.Printf("File with ISRC %s already exists: %s\n", track.ISRC, existingFile)
		return "EXISTS:" + existingFile, nil
	}

	// Build filename based on format settings
	filename := buildFilename(safeTitle, safeArtist, track.TrackPos, filenameFormat, includeTrackNumber, position, useAlbumTrackNumber)
	filepath := filepath.Join(outputDir, filename)

	if fileInfo, err := os.Stat(filepath); err == nil && fileInfo.Size() > 0 {
		fmt.Printf("File already exists: %s (%.2f MB)\n", filepath, float64(fileInfo.Size())/(1024*1024))
		return "EXISTS:" + filepath, nil
	}

	fmt.Println("Downloading FLAC file...")
	if err := d.DownloadFile(downloadURL, filepath); err != nil {
		return "", err
	}

	fmt.Printf("Downloaded: %s\n", filepath)

	coverPath := ""
	if track.Album.CoverXL != "" {
		coverPath = filepath + ".cover.jpg"
		fmt.Println("Downloading cover art...")
		if err := d.DownloadCoverArt(track.Album.CoverXL, coverPath); err != nil {
			fmt.Printf("Warning: Failed to download cover art: %v\n", err)
		} else {
			defer os.Remove(coverPath)
		}
	}

	fmt.Println("Embedding metadata and cover art...")
	// Use album track number if in album folder structure, otherwise use playlist position
	trackNumberToEmbed := 0
	if position > 0 {
		if useAlbumTrackNumber && track.TrackPos > 0 {
			trackNumberToEmbed = track.TrackPos
		} else {
			trackNumberToEmbed = position
		}
	}

	metadata := Metadata{
		Title:       trackTitle,
		Artist:      artists,
		Album:       albumTitle,
		Date:        track.ReleaseDate,
		TrackNumber: trackNumberToEmbed,
		DiscNumber:  track.DiskNumber,
		ISRC:        track.ISRC,
	}

	if err := EmbedMetadata(filepath, metadata, coverPath); err != nil {
		return "", fmt.Errorf("failed to embed metadata: %w", err)
	}

	fmt.Println("Metadata embedded successfully!")
	fmt.Println("✓ Downloaded successfully from Deezer")
	return filepath, nil
}

func (d *DeezerDownloader) DownloadBySpotifyID(spotifyTrackID, outputDir, filenameFormat string, includeTrackNumber bool, position int, spotifyTrackName, spotifyArtistName, spotifyAlbumName string, useAlbumTrackNumber bool) (string, error) {
	// Get Deezer URL from Spotify track ID
	deezerURL, err := d.GetDeezerURLFromSpotify(spotifyTrackID)
	if err != nil {
		return "", err
	}

	return d.DownloadByURL(deezerURL, outputDir, filenameFormat, includeTrackNumber, position, spotifyTrackName, spotifyArtistName, spotifyAlbumName, useAlbumTrackNumber)
}