package main

import (
	"encoding/json"
	"log"
	"net/http"
	"strings"
	"time"

	"github.com/gorilla/mux"
)

type APIServer struct {
	Host string
	Port string
	Db   SQLiteDatabase
	Cfg  *Config
}

type APIError struct {
	Status string
	Error  string
}

func WriteJSON(w http.ResponseWriter, status int, v any) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(status)
	return json.NewEncoder(w).Encode(v)
}

func NewAPIServer(database SQLiteDatabase, cfg Config) *APIServer {
	return &APIServer{
		Host: cfg.Host,
		Db:   database,
		Cfg:  &cfg,
	}
}

func (s *APIServer) Start() {
	router := mux.NewRouter()
	router.HandleFunc("/race", s.CreateRace).Methods("POST")
	router.HandleFunc("/races", s.GetPreRaces).Methods("GET")
	router.HandleFunc("/race/{id}", s.DeletePreRace).Methods("DELETE")
	router.HandleFunc("/race/{id}", s.UpdatePreRace).Methods("PUT")
	router.HandleFunc("/race/{id}", s.GetPreRaceByID).Methods("GET")
	router.HandleFunc("/race/{title}", s.CreateRace).Methods("POST")
	router.HandleFunc("/releases", s.GetReleases).Methods("GET")

	log.Println("Listening for new Races")

	http.ListenAndServe(s.Host, router)

}

func (s *APIServer) GetPreRaceByID(w http.ResponseWriter, r *http.Request) {
	vars := mux.Vars(r)
	id := vars["id"]
	race := s.Db.FindRaceByID(id)
	WriteJSON(w, http.StatusOK, race)
}

func (s *APIServer) GetPreRaces(w http.ResponseWriter, r *http.Request) {
	races, err := s.Db.FindRaces()
	if err != nil {
		log.Println("Could not get races: ", err)
	}
	WriteJSON(w, http.StatusOK, races)
}

func (s *APIServer) CreateRace(w http.ResponseWriter, r *http.Request) {
	race := NewRace()
	_ = json.NewDecoder(r.Body).Decode(&race)
	defer r.Body.Close()
	race.OriginalPath = ""
	race.TorrentFile = ""
	race.NFOFile = ""

	// Race only for movie and serie
	if race.Type == "movie" || race.Type == "episode" && !strings.Contains(race.Category, "XXX") {
		race.PreRace = 1
		race.PreRaceStarted = time.Time.Unix(time.Now())

		log.Printf("New PreRace [%s] from [%s] started at [%s]", race.TorrentName, race.Indexer, time.Unix(race.PreRaceStarted, 0))

		raceExist := s.Db.FindRace(race.TorrentName, race.Indexer)

		if raceExist.ID == 0 {
			err := s.Db.CreateRace(race)
			if err != nil {
				log.Println("Could not create new race in db", err)
				WriteJSON(w, http.StatusForbidden, "{Error: Could not add prerace to database}")
			}
			WriteJSON(w, http.StatusOK, race)
			log.Printf("Adding prerace [%s] from [%s] to database", race.TorrentName, race.Indexer)
		} else {
			WriteJSON(w, http.StatusOK, APIError{Status: "ok", Error: "Race already in database"})
		}

		rls := NewRelease(*race, *s.Cfg, s.Db)
		rls.ProcessRelease(*s.Cfg)

		rlsExist := s.Db.FindRelease(*rls)

		if rlsExist.ID == 0 {
			err := s.Db.CreateRelease(*rls)
			if err != nil {
				log.Printf("Could not create new release [%s] in dbm error: %s", rls.TorrentName, err)
				WriteJSON(w, http.StatusForbidden, APIError{Status: "Not OK", Error: "Could not add release in db"})
			}
			log.Printf("Adding release [%s] to database", rls.Title)
		}

	}

}

func (s *APIServer) DeletePreRace(w http.ResponseWriter, r *http.Request) {

}

func (s *APIServer) UpdatePreRace(w http.ResponseWriter, r *http.Request) {

}

func (s *APIServer) GetReleases(w http.ResponseWriter, r *http.Request) {
	releases, err := s.Db.FindReleases()
	if err != nil {
		log.Println("Could not get releases: ", err)
	}
	WriteJSON(w, http.StatusOK, releases)
}