package main

import (
	"fmt"
	"io"
	"net/http"
	"os"
	"strconv"
	"strings"
	"time"
)

func (a *App) 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)
	}

	a.Status.Lock()
	a.Status.Size = estSize
	a.Status.Unlock()

	rdr, wrtr := io.Pipe()

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

	var total int64
	start := time.Now()
	a.Status.Lock()
	a.Status.Start = &start
	a.Status.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)

		a.Status.Lock()
		a.Status.Transferred = total
		a.Status.Unlock()
	}

	if err == io.EOF {
		return nil
	}

	return err
}

func (a *App) 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 = a.Library.Extract(fh)
	if err != nil {
		return fmt.Errorf("Installer: opening %w", err)
	}
	fh.Close()
	return nil
}

// installer runs in the background installing games either from a local path or
// a remote URL
func (a *App) installer() {
	var err error
	for u := range a.download {
		a.Status.Lock()
		Logger.Printf("Installer: running for URI: %s", u)
		a.Status.Running = true
		a.Status.Url = u
		a.Status.Unlock()

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

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

		a.LibraryReload()
	}
}