package main

import (
	"embed"
	"fmt"
	"io"
	"log"
	"net/http"
	"net/url"
	"os"
	"path/filepath"
	"regexp"

	"github.com/wailsapp/wails/v2"
	"github.com/wailsapp/wails/v2/pkg/options"
	"github.com/wailsapp/wails/v2/pkg/options/assetserver"
)

var Error *log.Logger
var Warning *log.Logger

func init() {
	log.SetFlags(log.Lmicroseconds | log.Lshortfile)

	Error = log.New(io.MultiWriter(os.Stderr, os.Stdout),
		fmt.Sprintf("%sERROR:%s ", "\033[0;101m", "\033[0m"),
		log.Lmicroseconds|log.Lshortfile)
	Warning = log.New(io.MultiWriter(os.Stdout),
		fmt.Sprintf("%sWarning:%s ", "\033[0;93m", "\033[0m"),
		log.Lmicroseconds|log.Lshortfile)
}

//go:embed all:frontend/dist
var assets embed.FS
var gamePath string
var versionRegex = regexp.MustCompile(`(\d+\.\d+\.\d+)`)

type Addon struct {
	Name string
	URL  *url.URL
}

func NewAddon(name, aurl string) *Addon {
	a := &Addon{Name: name}
	var err error
	a.URL, err = url.Parse(aurl)
	if err != nil {
		Error.Printf("invalid url: %s", aurl)
		return nil
	}
	return a
}

var addons = []*Addon{
	NewAddon("Channeler", "https://git.site.quack-lab.dev/dave/wow_channeler"),
}

func (a *Addon) GetRemoteTocURL() *url.URL {
	return a.URL.JoinPath("raw", "branch", "master", a.Name+".toc")
}
func (a *Addon) GetRemoteReleaseURL() *url.URL {
	return a.URL.JoinPath("media", "branch", "master", a.Name+".zip")
}
func (a *Addon) GetRemoteRelease() (body []byte, err error) {
	url := a.GetRemoteReleaseURL()
	response, err := http.Get(url.String())
	if err != nil {
		return nil, fmt.Errorf("error getting remote release: %w", err)
	}
	return io.ReadAll(response.Body)
}
func (a *Addon) GetLocalTocPath() string {
	return filepath.Join(gamePath, "Interface", "AddOns", a.Name, a.Name+".toc")
}
func (a *Addon) GetRemoteVersion() (version string, err error) {
	url := a.GetRemoteTocURL()
	log.Printf("Fetching remote version from %s", url.String())
	response, err := http.Get(url.String())
	if err != nil {
		return "", fmt.Errorf("error getting remote version: %w", err)
	}
	if response.StatusCode != http.StatusOK {
		return "", fmt.Errorf("error getting remote version with status: %s", response.Status)
	}
	defer response.Body.Close()
	body, err := io.ReadAll(response.Body)
	if err != nil {
		return "", fmt.Errorf("error reading remote version: %w", err)
	}
	return GetVersion(string(body))
}
func (a *Addon) GetLocalVersion() (version string, err error) {
	file, err := os.Open(a.GetLocalTocPath())
	if err != nil {
		return "", fmt.Errorf("error opening local toc: %w", err)
	}
	defer file.Close()
	body, err := io.ReadAll(file)
	if err != nil {
		return "", fmt.Errorf("error reading local toc: %w", err)
	}
	return GetVersion(string(body))
}
func (a *Addon) IsUpToDate() bool {
	remoteVersion, err := a.GetRemoteVersion()
	if err != nil {
		return false
	}
	localVersion, err := a.GetLocalVersion()
	if err != nil {
		return false
	}
	return remoteVersion == localVersion
}

func main() {
	gamePath = filepath.Join("C:\\", "Games", "WoWRuski")
	for _, addon := range addons {
		log.Printf("%#v", addon.IsUpToDate())
		log.Printf("%#v", addon.GetRemoteReleaseURL())
		body, err := addon.GetRemoteRelease()
		if err != nil {
			log.Printf("error getting remote release: %s", err)
			continue
		}
		log.Printf("%#v", string(body))
	}
	return
	app := NewApp()

	err := wails.Run(&options.App{
		Title:  "wails-template",
		Width:  1024,
		Height: 768,
		AssetServer: &assetserver.Options{
			Assets: assets,
		},
		BackgroundColour: &options.RGBA{R: 27, G: 38, B: 54, A: 1},
		OnStartup:        app.startup,
		Bind: []interface{}{
			app,
		},
	})

	if err != nil {
		println("Error:", err.Error())
	}
}