package main

import (
	"crypto/rsa"
	"database/sql"
	"log"
	"os"
	"path/filepath"
)

// If this is set we're doing a first-time installation
var install bool

// The developer public key
var publicKey *rsa.PublicKey

func init() {
	log.SetFlags(0)
}

func main() {
	if fileExists(lfd) && !opt.IgnoreLockfile {
		log.Fatal("Lockfile exists, are you running another installation? Re-run with -b to run regardless of the lockfile.")
	}

	if !fileExists(lmd) {
		install = true
	}

	m, err := get(opt.URL + "/ofmanifest.db")
	if err != nil {
		log.Fatal(err)
	}

	// In ofatomic, to ensure the files are legitimate it checks
	// *every file* for if the signature is correct. This is bad for
	// performance. Instead we verify the database and then trust its
	// hashes.
	if !opt.DisableSigning {
		ms, err := get(opt.URL + "ofmanifest.sig")
		if err != nil {
			log.Fatal(err)
		}
		if !verifySig(ms, m) {
			log.Fatal("invalid database signature")
		}
	}

	cd, err := os.UserCacheDir()
	if err != nil {
		log.Fatal("Failed to determine cache directory: " + err.Error())
	}

	mcd := filepath.Join(cd, "murse")
	tf := filepath.Join(mcd, "ofmanifest.db")

	err = os.WriteFile(tf, *m, 0777)
	if err != nil {
		log.Fatal(err)
	}

	db, err := sql.Open("sqlite", tf)
	if err != nil {
		log.Fatal(err)
	}

	defer db.Close()

	var lrev int
	var localFiles map[string]string
	if !install {
		err = manifest.read()
		if err != nil {
			log.Fatal(err)
		}

		localFiles, err = filesFromSQLite(db, manifest.DownloadedRevision)
		if err != nil {
			log.Fatal(err)
		}
		lrev = manifest.DownloadedRevision
	}

	nrev, err := latestRevisionFromSQL(db)
	if err != nil {
		log.Fatal(err)
	}

	newFiles, err := getRevisedFiles(db, lrev, nrev)
	if err != nil {
		log.Fatal(err)
	}

	if !fileExists(opt.Directory) {
		err := os.Mkdir(opt.Directory, 0700)
		if err != nil {
			log.Fatal("could not create game directory: " + err.Error())
		}
	}

	confdir := filepath.Join(opt.Directory, ".murse")

	if !fileExists(confdir) {
		err := os.Mkdir(confdir, 0700)
		if err != nil {
			log.Fatal("unable to create .murse directory: " + err.Error())
		}
	}

	lockInstall()
	defer unlockInstall()

	s, errs := startDownloadVerify(newFiles, localFiles)
	if !s {
		if len(errs) != 0 {
			for _, v := range errs {
				log.Println(v)
			}
			log.Fatal("Operation failed due to errors. Include this log if you file a bug report.")
		} else {
			log.Fatal("Download not completed.")
		}
		unlockInstall()
		os.Exit(1)

	}
	// Sadly ofatomic has no sense of files being removed
	//	if !install {
	//		remOutdated()
	//	}

	manifest.DownloadedRevision = lrev
	err = manifest.write()
	if err != nil {
		log.Fatal("Couldn't write manifest file, any custom files may be overwritten unless it is fixed: " + err.Error())
	}

	// Now we update the gameinfo.txt, so that the game will launch once everything
	// has been downloaded.
	if install {
		b, err := get("https://raw.githubusercontent.com/int-72h/ofatomic/main/ofatomic/gameinfo.txt")
		if err != nil {
			log.Fatal("Unable to download gameinfo.txt, game will not start: " + err.Error())
		}

		err = os.WriteFile(filepath.Join(opt.Directory, "gameinfo.txt"), *b, 0777)
		if err != nil {
			log.Fatal("Failed to write gameinfo.txt to disk: " + err.Error())
		}
	}

	log.Println("Completed successfully. Happy fragging!")
}