package main

import (
	"embed"
	"encoding/json"
	"fmt"
	"io"
	"log"
	"music-downloader/monochrome"
	"net/http"
	"os"
	"path"
	"strconv"
	"sync"
	"time"

	"go.senan.xyz/taglib"
)

func sendJSON(w http.ResponseWriter, data any, status int) {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(status)
	if err := json.NewEncoder(w).Encode(data); err != nil {
		http.Error(w, err.Error(), 500)
	}
}

func sendError(w http.ResponseWriter, msg string, err error, status int) {
	m := msg
	if err != nil {
		m = fmt.Sprintf("%s: %v", msg, err)
	}
	sendJSON(w, struct {
		Error string `json:"error"`
	}{
		Error: m,
	}, status)
}

//go:embed web/dist/*
var webDist embed.FS

type DownloadStatus = string

var (
	DownloadStatusAdded      = "ADDED"
	DownloadStatusInProgress = "IN_PROGRESS"
	DownloadStatusCompleted  = "COMPLETED"
)

type DownloadItem struct {
	sync.Mutex

	Status         DownloadStatus
	Album          monochrome.AlbumInfo
	InstalledFiles int
	TotalFiles     int
}

var downloads = map[int]*DownloadItem{}

func main() {
	musicDir := os.Getenv("MUSIC_DIR")
	if musicDir == "" {
		musicDir = "./Music"
	}

	mClient := monochrome.NewClient(monochrome.ClientConfig{
		ApiURL: "https://api.monochrome.tf",
	})

	mux := http.NewServeMux()

	mux.HandleFunc("GET /", func(w http.ResponseWriter, r *http.Request) {
		path := r.URL.Path
		if path == "/" {
			path = "/index.html"
		}
		filePath := "web/dist" + path
		http.ServeFileFS(w, r, webDist, filePath)
	})

	mux.HandleFunc("GET /search", func(w http.ResponseWriter, r *http.Request) {
		q := r.URL.Query().Get("q")

		results, err := mClient.SearchAlbum(q)
		if err != nil {
			sendError(w, "failed to find albums", err, 404)
			return
		}

		sendJSON(w, results, 200)
	})

	mux.HandleFunc("GET /cover/{id}", func(w http.ResponseWriter, r *http.Request) {
		coverImg, err := mClient.AlbumCoverImage(r.PathValue("id"))
		if err != nil {
			sendError(w, "failed to download album cover", err, 500)
			return
		}

		w.Header().Set("Content-Type", "image/jpeg")
		w.WriteHeader(200)
		if _, err := w.Write(coverImg); err != nil {
			sendError(w, "failed to send response", err, 500)
			return
		}
	})

	mux.HandleFunc("GET /downloads", func(w http.ResponseWriter, r *http.Request) {
		type item struct {
			ID             int                  `json:"id"`
			Album          monochrome.AlbumInfo `json:"album"`
			InstalledFiles int                  `json:"installedFiles"`
			TotalFiles     int                  `json:"totalFiles"`
		}
		items := []item{}
		for id, download := range downloads {
			items = append(items, item{
				ID:             id,
				Album:          download.Album,
				InstalledFiles: download.InstalledFiles,
				TotalFiles:     download.TotalFiles,
			})
		}
		sendJSON(w, items, 200)
	})

	mux.HandleFunc("GET /download-album/{id}", func(w http.ResponseWriter, r *http.Request) {
		id, err := strconv.Atoi(r.PathValue("id"))
		if err != nil {
			sendError(w, "failed to parse id from request url", err, 500)
			return
		}

		album, err := mClient.AlbumInfo(id)
		if err != nil {
			sendError(w, "failed to get album info", err, 500)
			return
		}

		if album == nil {
			sendError(w, "album not found", nil, 404)
			return
		}

		downloads[album.ID] = &DownloadItem{
			Status:         DownloadStatusAdded,
			Album:          *album,
			InstalledFiles: 0,
			TotalFiles:     album.NumberOfTracks,
		}

		sendJSON(w, struct {
			Ok bool `json:"ok"`
		}{true}, 200)
	})

	go func() {
		for {
			time.Sleep(1 * time.Second)
			if len(downloads) == 0 {
				continue
			}

			for _, download := range downloads {
				if download.Status != DownloadStatusAdded {
					continue
				}

				go func() {
					download.Status = DownloadStatusInProgress

					albumCoverImg, err := mClient.AlbumCoverImage(download.Album.CoverID)
					if err != nil {
						log.Printf("failed to download album cover: %v\n", err)
					}

					dirPath := path.Join(musicDir, download.Album.Title)
					if err := os.Mkdir(dirPath, 0777); err != nil {
						return
					}

					var wg sync.WaitGroup
					for _, track := range download.Album.Items {
						wg.Go(func() {
							info, err := mClient.TrackInfo(track.Item.ID, track.Item.AudioQuality)
							if err != nil {
								log.Printf("failed to get track info: %v\n", err)
								return
							}

							manifest, err := mClient.DecodeManifest(info.Manifest)
							if err != nil {
								log.Printf("failed to decode track manifest: %v\n", err)
								return
							}

							if manifest.EncryptionType != monochrome.TrackManifestEncryptionNone {
								log.Println("file is encrypted; can't download")
								return
							}

							if len(manifest.URLs) == 0 {
								log.Println("track manifest doesn't have urls array")
								return
							}

							resp, err := http.Get(manifest.URLs[0])
							if err != nil {
								log.Printf("failed to download track data: %v\n", err)
								return
							}
							defer resp.Body.Close()

							data, err := io.ReadAll(resp.Body)
							if err != nil {
								log.Printf("failed to read track data: %v\n", err)
								return
							}

							fPath := path.Join(musicDir, download.Album.Title, track.Item.Title+".flac")
							if err := os.WriteFile(fPath, data, 0644); err != nil {
								log.Printf("failed to save track file: %v\n", err)
								return
							}

							artists := []string{}
							for _, artist := range download.Album.Artists {
								artists = append(artists, artist.Name)
							}

							if err := taglib.WriteTags(fPath, map[string][]string{
								taglib.Artist:      {download.Album.Artist.Name},
								taglib.Artists:     artists,
								taglib.AlbumArtist: artists,
								taglib.TrackNumber: {strconv.Itoa(track.Item.TrackNumber)},
								taglib.Album:       {download.Album.Title},
								taglib.Title:       {track.Item.Title},
								taglib.ReleaseDate: {download.Album.ReleaseDate},
							}, 0); err != nil {
								log.Printf("failed to add metadata tags to track file: %v\n", err)
							}

							if err := taglib.WriteImage(fPath, albumCoverImg); err != nil {
								log.Printf("failed to add album cover to track metadata: %v\n", err)
							}

							download.Lock()
							download.InstalledFiles++
							download.Unlock()
						})
					}

					wg.Wait()
					download.Status = DownloadStatusCompleted
				}()
			}
		}
	}()

	log.Println("starting http server")
	if err := http.ListenAndServe(":5000", mux); err != nil {
		log.Fatalf("failed to start http server: %v\n", err)
	}
}