package main

import (
	"encoding/json"
	"fmt"
	"io"
	"os"
	"strings"
	"sync"

	"sirherobrine23.com.br/go-bds/go-bds/bedrock"
	"sirherobrine23.com.br/go-bds/go-bds/utils/semver"
	"sirherobrine23.com.br/go-bds/request/gitea"
	gitea_api "sirherobrine23.com.br/go-bds/request/gitea/structs"
)

var (
	RootURL        = "https://sirherobrine23.com.br/api"
	Token   string = (func() string {
		if giteaToken := os.Getenv("GITEA_TOKEN"); len(giteaToken) > 0 {
			return giteaToken
		} else if ghToken := os.Getenv("GH_TOKEN"); len(ghToken) > 0 {
			return ghToken
		} else if githubToken := os.Getenv("GITHUB_TOKEN"); len(githubToken) > 0 {
			return githubToken
		}
		return ""
	})()
)

func processVersion() error {
	var versions, localVersions bedrock.Versions
	localFile, err := os.OpenFile("./versions.json", os.O_RDWR, 0)
	if err != nil {
		return err
	}
	defer localFile.Close()

	// Load versions to slice
	if err := json.NewDecoder(localFile).Decode(&localVersions); err != nil {
		return err
	}
	fmt.Printf("Loaded %d versions\n", len(localVersions))

	fmt.Println("Fetcing versions from minecraft.net")
	if err := versions.FetchFromMinecraftDotNet(); err != nil {
		return err
	}

	fmt.Printf("Versions located: %d\n", len(versions))
	if len(versions) == 0 {
		return fmt.Errorf("no versions found")
	}

	versions = append(versions, &bedrock.Version{
		Version: "1.21.120.4",
		Plaforms: map[string]*bedrock.PlatformVersion{
			"linux/amd64": {
				ZipFile: "https://www.minecraft.net/bedrockdedicatedserver/bin-linux/bedrock-server-1.21.120.4.zip",
				ZipSHA1: "ff7d4a36c1b1617f2c48d3e2ceeb3e714cbcea56",
			},
			"windows/amd64": {
				ZipFile: "https://www.minecraft.net/bedrockdedicatedserver/bin-win/bedrock-server-1.21.120.4.zip",
				ZipSHA1: "91075a634bc0fba704764877520266d9b5255372",
			},
		},
	})

	teaClient, err := gitea.NewClient(RootURL, "go-bds", "BedrockFetch", Token)
	if err != nil {
		return err
	}

	for _, version := range versions {
		if localVersions.HasVersion(version.Version) {
			fmt.Printf("Version aredy published: %s\n", version.Version)
			continue
		}
		fmt.Printf("Publishing version %s to Releaser\n", version.Version)

		release, err := teaClient.ReleaseTag(version.Version)
		if err != nil {
			release, err = teaClient.CreateRelease(&gitea_api.CreateReleaseOption{
				TagName:      version.Version,
				IsPrerelease: version.IsPreview,
				Title:        fmt.Sprintf("Bedrock server %s", version.Version),
			})
		}

		if err != nil {
			fmt.Printf("cannot make release to %s, error: %s\n", version.Version, err.Error())
			return err
		}

		newVersion := &bedrock.Version{
			Version:   version.Version,
			IsPreview: version.IsPreview,
			Docker:    nil,
			Plaforms:  map[string]*bedrock.PlatformVersion{},
		}
		localVersions = append(localVersions, newVersion)

		for platform, info := range version.Plaforms {
			fmt.Printf("Uploading server from %s\n", platform)
			name := strings.ReplaceAll(platform, "/", "_") + ".tgz"

			r, w := io.Pipe()
			var fileInfo *gitea_api.Attachment
			var err2 error

			wait := &sync.WaitGroup{}
			wait.Add(1)
			go func() {
				defer wait.Done()
				fileInfo, err2 = teaClient.UploadAsset(int(release.ID), name, r)
				if err2 != nil {
					fmt.Printf("Error on upload: %s\n", err2)
					r.Close()
				}
			}()

			fmt.Printf("Converting %s %s to tar.gz...\n", version.Version, platform)
			defer w.Close()
			sha1, err := info.ConvertTar(w)
			if err != nil {
				return err
			}

			w.Close()
			wait.Wait()
			if err2 != nil {
				return err2
			}

			fmt.Printf("Server (%s %s) release, Sha1: %s\n", version.Version, platform, sha1)
			newVersion.Plaforms[platform] = &bedrock.PlatformVersion{
				ReleaseDate: info.ReleaseDate,
				ZipSHA1:     info.ZipSHA1,
				ZipFile:     info.ZipFile,
				TarSHA1:     sha1,
				TarFile:     fileInfo.DownloadURL,
			}
		}
	}

	semver.Sort(localVersions)
	if _, err = localFile.Seek(0, 0); err != nil {
		return err
	} else if err = localFile.Truncate(0); err != nil {
		return err
	}

	enc := json.NewEncoder(localFile)
	enc.SetIndent("", "  ")
	return enc.Encode(localVersions)
}

func main() {
	if err := processVersion(); err != nil {
		fmt.Println(err.Error())
		os.Exit(1)
	}
}