package provider

import (
	"archive/zip"
	"conjure-os/lib/config"
	"conjure-os/lib/models"
	"encoding/json"
	"fmt"
	"io"
	"io/fs"
	"log"
	"net/http"
	"net/url"
	"os"
	"path/filepath"
	"strings"

	"gopkg.in/yaml.v3"
)

var token string

func Update() {
	//requestURL := fmt.Sprintf("http://localhost:%d", 8080)
	//login(requestURL)
	//allGames(requestURL)
}

type AuthResponse struct {
	Token string `json:"token"`
}

func login(requestURL string) {
	client := &http.Client{}
	form := url.Values{
		"username": {"test"},
		"password": {"test"}}
	req, _ := http.NewRequest("POST", requestURL+"/login", strings.NewReader(form.Encode()))
	req.Header.Set("API-Version", "1")
	req.Header.Add("Content-Type", "application/x-www-form-urlencoded")
	res, err := client.Do(req)
	check(err)
	var auth AuthResponse
	err = json.NewDecoder(res.Body).Decode(&auth)
	check(err)
	token = auth.Token
}

func allGames(requestURL string) {

	client := &http.Client{}
	req, _ := http.NewRequest("GET", requestURL+"/games", nil)
	req.Header.Set("Authorization", token)
	req.Header.Set("API-Version", "1")
	res, err := client.Do(req)

	check(err)
	fmt.Printf("client: status code: %d\n", res.StatusCode)
}

func GetOrSetEnvKey(key string, defaultValue string) string {
	value, exist := os.LookupEnv(key)
	if exist {
		return value
	}
	err := os.Setenv(key, defaultValue)
	if err != nil {
		log.Println(err)
	}
	return defaultValue
}

func GetConjureGameInfo() []models.Game {

	gamePath := config.GetDefaultConjureGamesDirectory()

	entrie, err := os.ReadDir(gamePath)
	if err != nil {
		log.Fatal(err)
	}

	var games []models.Game

	for _, e := range entrie {
		if e.IsDir() {
			newGames := readFolder(e, gamePath)
			games = append(newGames, games...)
		} else if filepath.Ext(e.Name()) == ".conj" {
			zipPath := filepath.Join(gamePath, e.Name())
			r, err := zip.OpenReader(zipPath)
			if err != nil {
				log.Fatal(err)
			}
			defer r.Close()

			fmt.Println("Contents of", zipPath)
			for _, f := range r.File {
				printIndentedPath(f.Name)
				if f.Name == "metadata.txt" {
					rc, err := f.Open()
					if err != nil {
						log.Fatal(err)
					}
					defer rc.Close()

					fmt.Println("Contents of metadata.txt:")
					_, err = io.Copy(os.Stdout, rc)
					if err != nil {
						log.Fatal(err)
					}
				}
			}
		}
	}

	if len(games) > 0 {
		fmt.Println("Found Conjure Games: " + string(rune(len(games))))
	} else {
		fmt.Println("No Conjure games Found")
	}
	return games
}

// Helper to print tree-like structure
func printIndentedPath(path string) {
	parts := strings.Split(path, "/")
	for i, part := range parts {
		if part == "" {
			continue
		}
		fmt.Print(strings.Repeat("  ", i))
		fmt.Println(part)
	}
}

func readFolder(entry fs.DirEntry, path string) []models.Game {
	newPath := path + "/" + entry.Name()
	entries, err := os.ReadDir(newPath)
	check(err)

	var games []models.Game

	for _, e := range entries {
		if e.IsDir() {
			games = append(games, readFolder(e, newPath)...)
		} else {
			filenamesplit := strings.Split(e.Name(), ".")

			if filenamesplit[1] == "conf" && filenamesplit[2] == "yml" {
				game := parseGameInfoFromFile(newPath + "/" + e.Name())
				games = append(games, game)
			}
		}
	}
	return games
}

func parseGameInfoFromFile(path string) models.Game {
	data, err := os.ReadFile(path)
	check(err)
	game := models.Game{}
	err = yaml.Unmarshal(data, &game)
	check(err)
	return game
}

func check(e error) {
	if e != nil {
		panic(e)
	}
}