package main

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

	"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) GetRemoteToc() *url.URL {
	return a.URL.JoinPath("raw", "branch", "master", a.Name+".toc")
}
func (a *Addon) GetLocalToc() string {
	return filepath.Join(gamePath, "Interface", "AddOns", a.Name, a.Name+".toc")
}
func (a *Addon) GetRemoteVersion() (version string, err error) {
	url := a.GetRemoteToc()
	log.Printf("Fetching remote version from %s", url.String())
	response, err := http.Get(url.String())
	if err != nil {
		log.Printf("error getting remote version: %s", err)
		return "", err
	}
	if response.StatusCode != http.StatusOK {
		log.Printf("error getting remote version: %s", response.Status)
		return "", fmt.Errorf("error getting remote version: %s", response.Status)
	}
	defer response.Body.Close()
	body, err := io.ReadAll(response.Body)
	if err != nil {
		log.Printf("error reading remote version: %s", err)
		return "", err
	}
	log.Printf("Remote version: %s", string(body))
	lines := strings.Split(string(body), "\n")
	for _, line := range lines {
		if strings.HasPrefix(line, "## Version") {
			version := versionRegex.FindString(line)
			log.Printf("remote version: %s", version)
			return version, nil
		}
	}
	return "", fmt.Errorf("no version found")
}
func (a *Addon) GetLocalVersion() string {
	file, err := os.Open(a.GetLocalToc())
	if err != nil {
		log.Printf("error opening local toc: %s", err)
		return ""
	}
	defer file.Close()
	body, err := io.ReadAll(file)
	if err != nil {
		log.Printf("error reading local toc: %s", err)
		return ""
	}
	lines := strings.Split(string(body), "\n")
	for _, line := range lines {
		if strings.HasPrefix(line, "## Version") {
			version := strings.TrimSpace(strings.TrimPrefix(line, "## Version"))
			log.Printf("local version: %s", version)
			return version
		}
	}
	return ""
}

func main() {
	gamePath = filepath.Join("C:\\", "Games", "WoWRuski")
	for _, addon := range addons {
		log.Printf("%#v", addon.GetLocalToc())
		log.Printf("%#v", addon.GetRemoteToc())
		remoteVersion, err := addon.GetRemoteVersion()
		if err != nil {
			log.Printf("error getting remote version: %s", err)
			continue
		}
		log.Printf("%#v", remoteVersion)
		log.Printf("%#v", addon.GetLocalVersion())
	}
	return
	// Create an instance of the app structure
	app := NewApp()

	// Create application with options
	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())
	}
}