package admin

import (
	"fmt"
	"net/http"
	"os"
	"strings"

	"arimelody-web/admin/templates"
	"arimelody-web/controller"
	"arimelody-web/model"
)

func serveReleases(app *model.AppState) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        session := r.Context().Value("session").(*model.Session)

        slices := strings.Split(strings.TrimPrefix(r.URL.Path, "/releases")[1:], "/")
        releaseID := slices[0]

        var action string = ""
        if len(slices) > 1 {
            action = slices[1]
        }

        if len(releaseID) > 0 {
            serveRelease(app, releaseID, action).ServeHTTP(w, r)
            return
        }

        type ReleasesData struct {
            adminPageData
            Releases    []*model.Release
        }

        releases, err := controller.GetAllReleases(app.DB, false, 0, true)
        if err != nil {
            fmt.Fprintf(os.Stderr, "WARN: Failed to fetch releases: %s\n", err)
            http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
            return
        }

        err = templates.ReleasesTemplate.Execute(w, ReleasesData{
            adminPageData: adminPageData{
                Path: r.URL.Path,
                Session: session,
            },
            Releases: releases,
        })
        if err != nil {
            fmt.Fprintf(os.Stderr, "WARN: Failed to serve releases page: %s\n", err)
            http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
            return
        }
    })
}

func serveRelease(app *model.AppState, releaseID string, action string) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        session := r.Context().Value("session").(*model.Session)

        release, err := controller.GetRelease(app.DB, releaseID, true)
        if err != nil {
            if strings.Contains(err.Error(), "no rows") {
                http.NotFound(w, r)
                return
            }
            fmt.Printf("WARN: Failed to fetch full release data for %s: %s\n", releaseID, err)
            http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
            return
        }

        if len(action) > 0 {
            switch action {
            case "editcredits":
                serveEditCredits(release).ServeHTTP(w, r)
                return
            case "addcredit":
                serveAddCredit(app, release).ServeHTTP(w, r)
                return
            case "newcredit":
                serveNewCredit(app).ServeHTTP(w, r)
                return
            case "editlinks":
                serveEditLinks(release).ServeHTTP(w, r)
                return
            case "edittracks":
                serveEditTracks(release).ServeHTTP(w, r)
                return
            case "addtrack":
                serveAddTrack(app, release).ServeHTTP(w, r)
                return
            case "newtrack":
                serveNewTrack(app).ServeHTTP(w, r)
                return
            }
            http.NotFound(w, r)
            return
        }

        type ReleaseResponse struct {
            adminPageData
            Release *model.Release
        }

        for i, track := range release.Tracks {
            track.Number = i + 1
        }

        err = templates.EditReleaseTemplate.Execute(w, ReleaseResponse{
            adminPageData: adminPageData{ Path: r.URL.Path, Session: session },
            Release: release,
        })
        if err != nil {
            fmt.Printf("WARN: Failed to serve admin release page for %s: %s\n", release.ID, err)
            http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
        }
    })
}

func serveEditCredits(release *model.Release) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        w.Header().Set("Content-Type", "text/html")
        err := templates.EditCreditsTemplate.Execute(w, release)
        if err != nil {
            fmt.Printf("WARN: Failed to serve edit credits component for %s: %s\n", release.ID, err)
            http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
        }
    })
}

func serveAddCredit(app *model.AppState, release *model.Release) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        artists, err := controller.GetArtistsNotOnRelease(app.DB, release.ID)
        if err != nil {
            fmt.Printf("WARN: Failed to fetch artists not on %s: %s\n", release.ID, err)
            http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
            return
        }

        type response struct {
            ReleaseID   string;
            Artists     []*model.Artist
        }

        w.Header().Set("Content-Type", "text/html")
        err = templates.AddCreditTemplate.Execute(w, response{
            ReleaseID: release.ID,
            Artists: artists,
        })
        if err != nil {
            fmt.Printf("WARN: Failed to serve add credits component for %s: %s\n", release.ID, err)
            http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
        }
    })
}

func serveNewCredit(app *model.AppState) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        artistID := strings.Split(r.URL.Path, "/")[3]
        artist, err := controller.GetArtist(app.DB, artistID)
        if err != nil {
            fmt.Printf("WARN: Failed to fetch artist %s: %s\n", artistID, err)
            http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
            return
        }
        if artist == nil {
            http.NotFound(w, r)
            return
        }

        w.Header().Set("Content-Type", "text/html")
        err = templates.NewCreditTemplate.Execute(w, artist)
        if err != nil {
            fmt.Printf("WARN: Failed to serve new credit component for %s: %s\n", artist.ID, err)
            http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
        }
    })
}

func serveEditLinks(release *model.Release) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        w.Header().Set("Content-Type", "text/html")
        err := templates.EditLinksTemplate.Execute(w, release)
        if err != nil {
            fmt.Printf("WARN: Failed to serve edit links component for %s: %s\n", release.ID, err)
            http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
        }
    })
}

func serveEditTracks(release *model.Release) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        w.Header().Set("Content-Type", "text/html")

        type editTracksData struct { Release *model.Release }

        err := templates.EditTracksTemplate.Execute(w, editTracksData{ Release: release })
        if err != nil {
            fmt.Printf("WARN: Failed to serve edit tracks component for %s: %s\n", release.ID, err)
            http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
        }
    })
}

func serveAddTrack(app *model.AppState, release *model.Release) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        tracks, err := controller.GetTracksNotOnRelease(app.DB, release.ID)
        if err != nil {
            fmt.Printf("WARN: Failed to fetch tracks not on %s: %s\n", release.ID, err)
            http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
            return
        }

        type response struct {
            ReleaseID   string;
            Tracks      []*model.Track
        }

        w.Header().Set("Content-Type", "text/html")
        err = templates.AddTrackTemplate.Execute(w, response{
            ReleaseID: release.ID,
            Tracks: tracks,
        })
        if err != nil {
            fmt.Printf("WARN: Failed to add tracks component for %s: %s\n", release.ID, err)
            http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
        }
    })
}

func serveNewTrack(app *model.AppState) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        trackID := strings.Split(r.URL.Path, "/")[3]
        track, err := controller.GetTrack(app.DB, trackID)
        if err != nil {
            fmt.Printf("WARN: Failed to fetch track %s: %s\n", trackID, err)
            http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
            return
        }
        if track == nil {
            http.NotFound(w, r)
            return
        }

        w.Header().Set("Content-Type", "text/html")
        err = templates.NewTrackTemplate.Execute(w, track)
        if err != nil {
            fmt.Printf("WARN: Failed to serve new track component for %s: %s\n", track.ID, err)
            http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
        }
    })
}