package main

import (
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"net/url"
	"os"
	"strconv"
	"strings"
	"sync"
	"time"
)

type statusInfo struct {
	Running     bool
	Error       error
	Url         string
	Transferred int64
	Size        int64
	Start       *time.Time
}

var (
	status = struct {
		m *sync.RWMutex
		s *statusInfo
	}{
		m: &sync.RWMutex{},
		s: &statusInfo{Running: false},
	}

	getPath = make(chan string)
)

func statsHandler(w http.ResponseWriter, r *http.Request) {
	status.m.RLock()
	defer status.m.RUnlock()

	w.Header().Add("Content-type", "application/json")

	enc := json.NewEncoder(w)

	err := enc.Encode(status.s)
	if err != nil {
		Logger.Println("While encoding status: ", err)
	}
	return
}

func installHttp(u string) error {
	Logger.Println("Installer: loading from url")
	resp, err := http.Get(u)
	if err != nil {
		return fmt.Errorf("Installer: getting %w", err)
	}

	estSize, err := strconv.ParseInt(resp.Header.Get("Estimated-size"), 10, 64)
	if err != nil {
		return fmt.Errorf("Failed to convert estimated size header: %w", err)
	}

	status.m.Lock()
	status.s.Size = estSize
	status.m.Unlock()

	rdr, wrtr := io.Pipe()

	go func() {
		err = Lib.Extract(rdr)
		if err != nil {
			Logger.Printf("Installer: extracting %s", err)
		}
		resp.Body.Close()
	}()

	var total int64
	start := time.Now()
	status.m.Lock()
	status.s.Start = &start
	status.m.Unlock()
	for {
		var n int64
		n, err = io.CopyN(wrtr, resp.Body, 100*1024*1024)
		if err == io.EOF {
			break
		} else if err != nil {
			Logger.Printf("Error encountered read from response body in installer: %s", err)
			break
		}

		total += n
		mb := float64(total / 1024 / 1024)
		rate := mb / time.Since(start).Seconds()

		Logger.Printf("Downloading from %s, Size: %s, %0.1f%% Done, Rate: %.2f mb/s",
			u, formatBytes(estSize), float64(total)/float64(estSize)*100, rate)

		status.m.Lock()
		status.s.Transferred = total
		status.m.Unlock()
	}

	if err == io.EOF {
		return nil
	}

	return err
}

func installPath(p string) error {
	Logger.Println("Installer: loading from filesystem")
	fh, err := os.Open(p)
	if err != nil {
		return fmt.Errorf("Installer: opening %w", err)
	}

	err = Lib.Extract(fh)
	if err != nil {
		return fmt.Errorf("Installer: opening %w", err)
	}
	fh.Close()
	return nil
}

// installer handles installing games either from a local path or a
// remote URL
func installer(urls <-chan string) {
	var err error
	for u := range urls {
		status.m.Lock()
		Logger.Printf("Installer: running for URI: %s", u)
		status.s.Running = true
		status.s.Url = u
		status.m.Unlock()

		if strings.HasPrefix(u, "http") {
			err = installHttp(u)
		} else {
			err = installPath(u)
		}

		status.m.Lock()
		status.s.Running = false
		status.s.Error = err
		Logger.Printf("Installer: Completed request %s Errors: %s", u, err)
		status.m.Unlock()

		reloadLib()
	}
}

func gameInstaller(w http.ResponseWriter, r *http.Request) {
	if unauthorizedIfNotLocal(w, r) {
		return
	}

	err := r.ParseForm()
	if err != nil {
		Logger.Printf("Installer: While parsing form: %s", err)
		http.Error(w, fmt.Sprintf("Invalid form: %s", err), 400)
		return
	}

	uri := r.Form.Get("uri")

	if strings.HasPrefix(uri, "http") {
		_, err := url.Parse(uri)
		if err != nil {
			Logger.Printf("Installer: While parsing url: %s", err)
			http.Error(w, fmt.Sprintf("Invalid url: %s", err), 400)
			return
		}
	} else {
		fi, err := os.Stat(uri)
		if err != nil {
			Logger.Printf("Installer: While parsing url: %s", err)
			http.Error(w, fmt.Sprintf("Invalid uri/path: %s", err), 400)
			return
		}

		if !fi.Mode().IsRegular() {
			Logger.Printf("Installer: While parsing url: %s", err)
			http.Error(w, fmt.Sprintf("Invalid uri/path: %s", err), 400)
			return
		}
	}

	Logger.Printf("Installer: Sending request for: %s to channel", uri)
	getPath <- uri

	http.Redirect(w, r, "/", 302)
}