package main

import (
	"bytes"
	"crypto/sha256"
	"errors"
	"fmt"
	"os"
	"os/exec"
	"path/filepath"
	"strings"
	"time"

	"go.wit.com/lib/debian"
	"go.wit.com/lib/env"
	"go.wit.com/lib/gui/shell"
	"go.wit.com/log"
)

func doPurge() error {
	// all paths should be relative to this BaseDir path
	if err := os.Chdir(env.GetPanic("BaseDir")); err != nil {
		log.Info("could not change to dir", env.GetPanic("BaseDir"), err)
		panic("could not change to dir")
	}
	var err error
	_, err = shell.RunVerbose([]string{"rm", "-rf", "dists"})

	return err
}

func makePackagesFile(arch string) (string, error) {
	os.Chdir(env.GetPanic("BaseDir"))

	if err := os.MkdirAll("dists/sid/main/binary-"+arch, 0755); err != nil {
		log.Info("did not work", err)
	} else {
		log.Info("did work")
	}

	if err := os.Chdir(me.pb.BaseDir); err != nil {
		me.argv.BadExit("no '"+me.pb.BaseDir+"' directory", err)
	}

	if !shell.IsDir("pool/") {
		me.argv.BadExit("no "+filepath.Join(me.pb.BaseDir, "pool")+" directory", errors.New("mount -a ? missing wit/pool/"))
	}

	log.Info("Processing dir", filepath.Join(me.pb.BaseDir, "pool"))

	newest := doGetNewest(arch)
	newest.SortPackage()
	thefile := debian.MakePackagesFile(newest)
	fullname := "dists/sid/main/binary-" + arch + "/Packages"
	if err := os.WriteFile(fullname, []byte(thefile), 0644); err != nil {
		return fullname, err
	}

	r, err := shell.RunVerbose([]string{"gzip", "-k", fullname})
	log.Info(r, err)

	return fullname + " is created", err
}

// r, err := shell.RunVerbose([]string{"gzip", fullname})
// panic("blah")
// shell.RunVerbose([]string{"bzip2", "-k", fullname})
// shell.RunVerbose([]string{"bzip2", fullname})

func doSignRelease() error {
	allfiles, _ := FindFiles("dists/sid/main")
	for i, filename := range allfiles {
		log.Info(i, filename)
	}

	releasePath := filepath.Join("dists/sid", "Release")

	rfile, _ := os.OpenFile(releasePath, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0644)
	fmt.Fprintf(rfile, "Origin: WIT.COM Debian Sid\n")
	fmt.Fprintf(rfile, "Label: WIT.COM Debian Sid\n")
	fmt.Fprintf(rfile, "Suite: sid\n")
	fmt.Fprintf(rfile, "Codename: sid\n")
	fmt.Fprintf(rfile, "Date: %s\n", time.Now().UTC().Format(time.RFC1123Z))
	fmt.Fprintf(rfile, "Architectures: riscv64 amd64 arm64 all\n")
	fmt.Fprintf(rfile, "Components: main\n")
	fmt.Fprintf(rfile, "Description: Tooling for RiscV, Semiconductor Designs & Private Clouds\n")

	/*
		fmt.Fprintf(rfile, "MD5SUM:\n")
		for i, filename := range allfiles {
			log.Info(i, filename)
			fileBytes, _ := os.ReadFile(filename)
			sum := fmt.Sprintf("%x", md5.Sum(fileBytes)) // deprecated
			newfile := strings.TrimPrefix(filename, "dists/sid/")
			fmt.Fprintf(rfile, " %s %d %s\n", sum, len(fileBytes), newfile)
		}
		fmt.Fprintf(rfile, "SHA1:\n")
		for i, filename := range allfiles {
			log.Info(i, filename)
			fileBytes, _ := os.ReadFile(filename)
			sum := fmt.Sprintf("%x", sha1.Sum(fileBytes))
			newfile := strings.TrimPrefix(filename, "dists/sid/")
			fmt.Fprintf(rfile, " %s %d %s\n", sum, len(fileBytes), newfile)
		}
	*/
	fmt.Fprintf(rfile, "SHA256:\n")
	for i, filename := range allfiles {
		log.Info(i, filename)
		fileBytes, _ := os.ReadFile(filename)
		sum := fmt.Sprintf("%x", sha256.Sum256(fileBytes))
		newfile := strings.TrimPrefix(filename, "dists/sid/")
		fmt.Fprintf(rfile, " %s %d %s\n", sum, len(fileBytes), newfile)
	}
	// fmt.Fprintf(rfile, "SHA1:\n")
	// fmt.Fprintf(rfile, "SHA256:\n")
	rfile.Close()

	gpgKeyID := env.GetPanic("gpgKeyID")
	// Sign the file
	log.Println("Signing with GPG key:", gpgKeyID)

	distPath := env.GetPanic("distPath")
	// Create InRelease
	cmdClearSign := exec.Command("gpg", "--default-key", gpgKeyID, "--clearsign", "-o", filepath.Join(distPath, "InRelease"), releasePath)
	if err := runCommand(cmdClearSign); err != nil {
		log.Printf("failed to create InRelease: %v\n", err)
	}

	// Create Release.gpg
	cmdDetachedSign := exec.Command("gpg", "--default-key", gpgKeyID, "-abs", "-o", filepath.Join(distPath, "Release.gpg"), releasePath)
	if err := runCommand(cmdDetachedSign); err != nil {
		log.Printf("failed to create Release.gpg: %v\n", err)
	}
	/*
		var sum string
		switch name {
		case "MD5Sum":
			sum = fmt.Sprintf("%x", md5.Sum(fileBytes))
		case "SHA1":
			sum = fmt.Sprintf("%x", sha1.Sum(fileBytes))
		case "SHA256":
			// FIX 3: Use the correct sha256.Sum256 function.
			sum = fmt.Sprintf("%x", sha256.Sum256(fileBytes))
	*/

	log.Info("Release   file:", releasePath)
	log.Info("InRelease file:", filepath.Join(distPath, "InRelease"))
	log.Info("")
	log.Info("Finished Everything")
	log.Info("")

	return nil
}

func runCommand(cmd *exec.Cmd) error {
	var stderr bytes.Buffer
	cmd.Stderr = &stderr
	err := cmd.Run()
	if err != nil {
		return fmt.Errorf("command '%s' failed: %v\nStderr: %s", cmd.String(), err, stderr.String())
	}
	return nil
}