package main

import (
	"bufio"
	"crypto/md5"
	"fmt"
	"io"
	"log"
	"os"
	"os/exec"
	"path/filepath"
	"strings"
)

const (
	slot    = "KSBx"
	mfolder = "projectm/pf/"
	ofolder = "ssbb.d/files/"
	pc      = "4333"
	gid     = "RSBEC3"
	gctsize = "106D8"
	gctpath = "RSBE01.gct"
	modname = "Project M 3.5 Netplay Build"
	wflags  = "-ovv"
)

var pmfp []string
var ofp []string

func cerr(err error) {
	if err != nil {
		log.Fatal(err)
	}
}

// Extract the contents of the SSBB iso
// In desperate need of a better option
func unpackIso() {
	cmd := exec.Command("wit-lin/wit",
		"extract", "-s", ".", "-1", "-n",
		"RSBE01", ".", "ssbb.d", "--psel=DATA",
		"-ovv")
	cmd.Stdout = os.Stdout
	cmd.Stderr = os.Stderr
	if err := cmd.Start(); err != nil {
		log.Fatal(err)
	}
	if err := cmd.Wait(); err != nil {
		log.Fatal(err)
	}
}

// Copy file from src -> dst
func copyFileContents(dst, src string) (n int64, err error) {
	in, err := os.Open(src)
	cerr(err)
	defer in.Close()

	out, err := os.Create(dst)
	cerr(err)
	defer out.Close()

	if n, err = io.Copy(out, in); err != nil {
		return n, err
	}
	err = out.Sync()

	return n, nil
}

// Scan through the file paths and copy over Project M files
func copyFiles() {
	for i := 0; i < len(pmfp); i++ {
		_, err := os.Stat(ofp[i])
		if os.IsNotExist(err) {
			dir, _ := filepath.Split(ofp[i])
			err := os.MkdirAll(dir, 0775)
			cerr(err)
		}
		n, err := copyFileContents(ofp[i], pmfp[i])
		cerr(err)
		fmt.Printf("--> %s (%d) [%d]\n", pmfp[i], n, len(pmfp)-i)
	}
	_, err := copyFileContents("ssbb.d/files/sound/smashbros_sound.brsar",
		"smashbros_sound.brsar")
	cerr(err)
}

// Patch the iso with gct codeset
func patchDol() {
	cmd := exec.Command("wit-lin/wit",
		"dolpatch", "ssbb.d/sys/main.dol",
		"NEW=TEXT,80001800,10C0",
		"LOAD=80001800,patch/codehandler.bin",
		"XML=patch/PatchCommon.xml",
		"805A14B8="+pc,
		"NEW=DATA,80570000,"+gctsize,
		"LOAD=80570000,"+gctpath)
	cmd.Stdout = os.Stdout
	cmd.Stderr = os.Stderr
	if err := cmd.Start(); err != nil {
		log.Fatal(err)
	}
	if err := cmd.Wait(); err != nil {
		log.Fatal(err)
	}
}

// Rebuild-the-Iso
func rebuildIso() {
	// cmd := exec.Command("wit-lin/wit",
	// 	"copy", "ssbb.d", "Project M Community.iso",
	// 	"-ovv", "--disc-id="+gid, "--boot-id="+gid,
	// 	"--tt-id="+slot, "--name", modname)
	cmd := exec.Command("wit-lin/wit",
		"copy", "ssbb.d", "Project M Community.iso",
		"-ovv", "--disc-id=RSBEC3", "--boot-id=RSBEC3",
		"--tt-id=KSBx", "--name", modname)
	cmd.Stdout = os.Stdout
	cmd.Stderr = os.Stderr
	if err := cmd.Start(); err != nil {
		log.Fatal(err)
	}
	if err := cmd.Wait(); err != nil {
		log.Fatal(err)
	}
}

// Clean up the mess
func cleanUp() {
	fmt.Println("Cleaning up the mess...")
	err := os.RemoveAll("ssbb.d")
	cerr(err)
}

// Add paths to either pmfp or ofp slices
func populatePaths() {
	err := filepath.Walk(".", WalkFunc)
	cerr(err)
}

// Walk function supplied to PopulatePaths
func WalkFunc(path string, info os.FileInfo, err error) error {
	ispm := strings.HasPrefix(path, mfolder)
	if !info.IsDir() && ispm {
		pmfp = append(pmfp, path)
		// Replace projectm/pf/ with wits crap
		dir, file := filepath.Split(path)
		dl := strings.ToLower(dir)
		ofpj := filepath.Join(dl, file)
		ofp = append(ofp, strings.Replace(ofpj, mfolder, ofolder, 1))
	}
	return nil
}

func genHash() {
	var iso string = "Project M Community.iso"
	fmt.Println("Generating md5 hash...")
	h := md5.New()
	o, err := os.Open(iso)
	cerr(err)
	defer o.Close()
	r := bufio.NewReader(o)
	io.Copy(h, r)
	fmt.Printf("%x %s\n", h.Sum(nil), iso)
}

func main() {
	unpackIso()
	populatePaths()
	copyFiles()
	patchDol()
	rebuildIso()
	cleanUp()
	genHash()
}