package api

import (
	"encoding/json"
	"fmt"
	"io/fs"
	"net/http"
	"os"
	"path/filepath"
	"strings"
	"time"

	"arimelody.me/arimelody.me/admin"
	"arimelody.me/arimelody.me/global"
	"arimelody.me/arimelody.me/music/model"
)

type releaseBodyJSON struct {
    ID              string              `json:"id"`
    Visible         *bool               `json:"visible"`
    Title           *string             `json:"title"`
    Description     *string             `json:"description"`
    ReleaseType     *model.ReleaseType  `json:"type"`
    ReleaseDate     *string             `json:"releaseDate"`
    Artwork         *string             `json:"artwork"`
    Buyname         *string             `json:"buyname"`
    Buylink         *string             `json:"buylink"`
}

func ServeCatalog() http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        type catalogItem struct {
            ID              string              `json:"id"`
            Title           string              `json:"title"`
            ReleaseType     model.ReleaseType   `json:"type"`
            ReleaseDate     time.Time           `json:"releaseDate"`
            Artwork         string              `json:"artwork"`
            Buylink         string              `json:"buylink"`
        }

        releases := []*model.Release{}
        err := global.DB.Select(&releases, "SELECT * FROM musicrelease ORDER BY release_date DESC")
        if err != nil {
            http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
            return
        }

        catalog := []catalogItem{}
        authorised := admin.GetSession(r) != nil
        for _, release := range releases {
            if !release.Visible && !authorised {
                continue
            }
            catalog = append(catalog, catalogItem{
                ID: release.ID,
                Title: release.Title,
                ReleaseType: release.ReleaseType,
                ReleaseDate: release.ReleaseDate,
                Artwork: release.Artwork,
                Buylink: release.Buylink,
            })
        }

        w.Header().Add("Content-Type", "application/json")
        err = json.NewEncoder(w).Encode(catalog)
        if err != nil {
            http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
            return
        }
    })
}

func CreateRelease() http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        if r.Method != http.MethodPost {
            http.NotFound(w, r)
            return
        }

        var data releaseBodyJSON
        err := json.NewDecoder(r.Body).Decode(&data)
        if err != nil {
            http.Error(w, http.StatusText(http.StatusBadRequest), http.StatusBadRequest)
            return
        }

        if data.ID == "" {
            http.Error(w, "Release ID cannot be empty\n", http.StatusBadRequest)
            return
        }
        
        title := data.ID
        if data.Title != nil && *data.Title != "" {
            title = *data.Title
        }

        description := ""
        if data.Description != nil && *data.Description != "" { description = *data.Description }
        
        releaseType := model.Single
        if data.ReleaseType != nil && *data.ReleaseType != "" { releaseType = *data.ReleaseType }

        releaseDate := time.Time{}
        if data.ReleaseDate != nil && *data.ReleaseDate != "" {
            releaseDate, err = time.Parse("2006-01-02T15:04", *data.ReleaseDate)
            if err != nil {
                http.Error(w, "Invalid release date", http.StatusBadRequest)
                return
            }
        } else {
            releaseDate = time.Date(time.Now().Year(), time.Now().Month(), time.Now().Day(), 0, 0, 0, 0, time.UTC)
        }

        artwork := "/img/default-cover-art.png"
        if data.Artwork != nil && *data.Artwork != "" { artwork = *data.Artwork }

        buyname := ""
        if data.Buyname != nil && *data.Buyname != "" { buyname = *data.Buyname }

        buylink := ""
        if data.Buylink != nil && *data.Buylink != "" { buylink = *data.Buylink }

        var release = model.Release{
            ID: data.ID,
            Visible: false,
            Title: title,
            Description: description,
            ReleaseType: releaseType,
            ReleaseDate: releaseDate,
            Artwork: artwork,
            Buyname: buyname,
            Buylink: buylink,
        }

        _, err = global.DB.Exec(
            "INSERT INTO musicrelease "+
            "(id, visible, title, description, type, release_date, artwork, buyname, buylink) "+
            "VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)",
            release.ID,
            release.Visible,
            release.Title,
            release.Description,
            release.ReleaseType,
            release.ReleaseDate.Format("2006-01-02 15:04:05"),
            release.Artwork,
            release.Buyname,
            release.Buylink)
        if err != nil {
            if strings.Contains(err.Error(), "duplicate key") {
                http.Error(w, fmt.Sprintf("Release %s already exists\n", data.ID), http.StatusBadRequest)
                return
            }
            fmt.Printf("Failed to create release %s: %s\n", release.ID, err)
            http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
            return
        }

        w.Header().Add("Content-Type", "application/json")
        w.WriteHeader(http.StatusCreated)
        err = json.NewEncoder(w).Encode(release)
        if err != nil {
            fmt.Printf("WARN: Release %s created, but failed to send JSON response: %s\n", release.ID, err)
            http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
        }
    })
}

func UpdateRelease(release model.Release) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        if r.URL.Path == "/" {
            http.NotFound(w, r)
            return
        }

        segments := strings.Split(r.URL.Path[1:], "/")
        var releaseID = segments[0]
        var exists int
        err := global.DB.Get(&exists, "SELECT count(*) FROM musicrelease WHERE id=$1", releaseID)
        if err != nil {
            fmt.Printf("Failed to update release: %s\n", err)
            http.Error(w, http.StatusText(http.StatusBadRequest), http.StatusBadRequest)
            return
        }

        if len(segments) == 2 {
            switch segments[1] {
            case "tracks":
                UpdateReleaseTracks(release).ServeHTTP(w, r)
            case "credits":
                UpdateReleaseCredits(release).ServeHTTP(w, r)
            case "links":
                UpdateReleaseLinks(release).ServeHTTP(w, r)
            }
            return
        }
        
        if len(segments) > 2 {
            http.NotFound(w, r)
            return
        }

        var data releaseBodyJSON
        err = json.NewDecoder(r.Body).Decode(&data)
        if err != nil {
            http.Error(w, http.StatusText(http.StatusBadRequest), http.StatusBadRequest)
            return
        }

        if data.ID != "" { release.ID = data.ID }
        if data.Visible != nil { release.Visible = *data.Visible }
        if data.Title != nil { release.Title = *data.Title }
        if data.Description != nil { release.Description = *data.Description }
        if data.ReleaseType != nil { release.ReleaseType = *data.ReleaseType }
        if data.ReleaseDate != nil {
            newDate, err := time.Parse("2006-01-02T15:04", *data.ReleaseDate)
            if err != nil {
                http.Error(w, "Invalid release date", http.StatusBadRequest)
                return
            }
            release.ReleaseDate = newDate
        }
        if data.Artwork != nil {
            if strings.Contains(*data.Artwork, ";base64,") {
                var artworkDirectory = filepath.Join("uploads", "musicart")
                filename, err := HandleImageUpload(data.Artwork, artworkDirectory, data.ID)

                // clean up files with this ID and different extensions
                err = filepath.Walk(artworkDirectory, func(path string, info fs.FileInfo, err error) error {
                    if path == filepath.Join(artworkDirectory, filename) { return nil }

                    withoutExt := strings.TrimSuffix(path, filepath.Ext(path))
                    if withoutExt != filepath.Join(artworkDirectory, release.ID) { return nil }

                    return os.Remove(path)
                })
                if err != nil {
                    fmt.Printf("WARN: Error while cleaning up artwork files: %s\n", err)
                }

                release.Artwork = fmt.Sprintf("/uploads/musicart/%s", filename)
            } else {
                release.Artwork = *data.Artwork
            }
        }

        if data.Buyname != nil { release.Buyname = *data.Buyname }
        if data.Buylink != nil { release.Buylink = *data.Buylink }

        _, err = global.DB.Exec(
            "UPDATE musicrelease SET "+
            "visible=$2, title=$3, description=$4, type=$5, release_date=$6, artwork=$7, buyname=$8, buylink=$9 "+
            "WHERE id=$1",
            release.ID,
            release.Visible,
            release.Title,
            release.Description,
            release.ReleaseType,
            release.ReleaseDate.Format("2006-01-02 15:04:05"),
            release.Artwork,
            release.Buyname,
            release.Buylink)
        if err != nil {
            fmt.Printf("FATAL: Failed to update release %s: %s\n", release.ID, err)
            http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
        }
    })
}

func UpdateReleaseTracks(release model.Release) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        var trackIDs = []string{}
        err := json.NewDecoder(r.Body).Decode(&trackIDs)
        if err != nil {
            http.Error(w, http.StatusText(http.StatusBadRequest), http.StatusBadRequest)
            return
        }

        tx := global.DB.MustBegin()
        tx.MustExec("DELETE FROM musicreleasetrack WHERE release=$1", release.ID)
        for i, trackID := range trackIDs {
            tx.MustExec(
                "INSERT INTO musicreleasetrack "+
                "(release, track, number) "+
                "VALUES ($1, $2, $3)",
                release.ID,
                trackID,
                i)
        }
        err = tx.Commit()
        if err != nil {
            fmt.Printf("Failed to update tracks for %s: %s\n", release.ID, err)
            http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
        }
    })
}

func UpdateReleaseCredits(release model.Release) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        type creditJSON struct {
            Artist  string
            Role    string
            Primary bool
        }
        var data []creditJSON
        err := json.NewDecoder(r.Body).Decode(&data)
        if err != nil {
            http.Error(w, http.StatusText(http.StatusBadRequest), http.StatusBadRequest)
            return
        }

        // clear duplicates
        type Credit struct {
            Role    string
            Primary bool
        }
        var credits = map[string]Credit{}
        for _, credit := range data {
            credits[credit.Artist] = Credit{
                Role: credit.Role,
                Primary: credit.Primary,
            }
        }

        tx := global.DB.MustBegin()
        tx.MustExec("DELETE FROM musiccredit WHERE release=$1", release.ID)
        for artistID := range credits {
            if credits[artistID].Role == "" {
                http.Error(w, fmt.Sprintf("Artist role cannot be blank (%s)", artistID), http.StatusBadRequest)
                return
            }

            var exists int
            _ = global.DB.Get(&exists, "SELECT count(*) FROM artist WHERE id=$1", artistID)
            if exists == 0 {
                http.Error(w, fmt.Sprintf("Artist %s does not exist\n", artistID), http.StatusBadRequest)
                return
            }

            tx.MustExec(
                "INSERT INTO musiccredit "+
                "(release, artist, role, is_primary) "+
                "VALUES ($1, $2, $3, $4)",
                release.ID,
                artistID,
                credits[artistID].Role,
                credits[artistID].Primary)
            }
        err = tx.Commit()
        if err != nil {
            fmt.Printf("Failed to update links for %s: %s\n", release.ID, err)
            http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
        }
    })
}

func UpdateReleaseLinks(release model.Release) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        if r.Method != http.MethodPut {
            http.NotFound(w, r)
            return
        }

        var links = []*model.Link{}
        err := json.NewDecoder(r.Body).Decode(&links)
        if err != nil {
            http.Error(w, http.StatusText(http.StatusBadRequest), http.StatusBadRequest)
            return
        }

        tx := global.DB.MustBegin()
        tx.MustExec("DELETE FROM musiclink WHERE release=$1", release.ID)
        for _, link := range links {
            tx.MustExec(
                "INSERT INTO musiclink "+
                "(release, name, url) "+
                "VALUES ($1, $2, $3)",
                release.ID,
                link.Name,
                link.URL)
        }
        err = tx.Commit()
        if err != nil {
            fmt.Printf("Failed to update links for %s: %s\n", release.ID, err)
            http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
        }
    })
}

func DeleteRelease(release model.Release) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        _, err := global.DB.Exec("DELETE FROM musicrelease WHERE id=$1", release.ID)
        if err != nil {
            fmt.Printf("Failed to delete release %s: %s\n", release.ID, err)
            http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
        }
    })
}