package svc // import "github.com/getwtxt/getwtxt/svc"

import (
	"bytes"
	"html/template"
	"io/ioutil"
	"os"
	"reflect"
	"testing"

	"github.com/getwtxt/registry"
)

func Test_initTemplates(t *testing.T) {
	initTestConf()

	tmpls = initTemplates()
	manual := template.Must(template.ParseFiles("../assets/tmpl/index.html"))

	t.Run("Checking if Deeply Equal", func(t *testing.T) {
		if !reflect.DeepEqual(tmpls, manual) {
			t.Errorf("Returned template doesn't match manual parse\n")
		}
	})
}

func Test_cacheUpdate(t *testing.T) {
	initTestConf()
	mockRegistry()
	killStatuses()

	cacheUpdate()
	urls := "https://gbmor.dev/twtxt.txt"
	newStatus := twtxtCache.Users[urls].Status

	t.Run("Checking for any data", func(t *testing.T) {

		if len(newStatus) <= 1 {
			t.Errorf("Statuses weren't pulled\n")
		}
	})
	t.Run("Checking if Deeply Equal", func(t *testing.T) {
		raw, _, _ := registry.GetTwtxt(urls)
		manual, _ := registry.ParseUserTwtxt(raw, "gbmor", urls)

		if !reflect.DeepEqual(newStatus, manual) {
			t.Errorf("Updated statuses don't match a manual fetch.\n")
		}
	})
}

func Benchmark_cacheUpdate(b *testing.B) {
	initTestConf()
	mockRegistry()
	b.ResetTimer()

	for i := 0; i < b.N; i++ {
		cacheUpdate()

		// make sure it's pulling new statuses
		// half the time so we get a good idea
		// of its performance in both cases.
		if i > 2 && i%2 == 0 {
			b.StopTimer()
			killStatuses()
			b.StartTimer()
		}
	}
}

func Test_pingAssets(t *testing.T) {
	initTestConf()
	tmpls = initTemplates()

	b := []byte{}
	buf := bytes.NewBuffer(b)

	cssStat, _ := os.Stat("../assets/style.css")
	css, _ := ioutil.ReadFile("../assets/style.css")
	indStat, _ := os.Stat("../assets/tmpl/index.html")
	tmpls.ExecuteTemplate(buf, "index.html", confObj.Instance)
	ind := buf.Bytes()

	pingAssets()

	t.Run("Checking if index Deeply Equal", func(t *testing.T) {
		if !reflect.DeepEqual(staticCache.index, ind) {
			t.Errorf("Index not equivalent to manual parse\n")
		}
	})
	t.Run("Checking index Mod Times", func(t *testing.T) {
		if indStat.ModTime() != staticCache.indexMod {
			t.Errorf("Index mod time mismatch\n")
		}
	})
	t.Run("Checking if CSS Deeply Equal", func(t *testing.T) {
		if !reflect.DeepEqual(staticCache.css, css) {
			t.Errorf("CSS not equivalent to manual read\n")
		}
	})
	t.Run("Checking CSS Mod Times", func(t *testing.T) {
		if cssStat.ModTime() != staticCache.cssMod {
			t.Errorf("CSS mod time mismatch\n")
		}
	})

}

func Benchmark_pingAssets(b *testing.B) {
	initTestConf()
	b.ResetTimer()

	for i := 0; i < b.N; i++ {
		pingAssets()

		// We'll only have to reload the cache occasionally,
		// so only start with an empty staticCache 25% of
		// the time.
		if float64(i) > (float64(b.N) * .75) {
			b.StopTimer()
			staticCache = &staticAssets{}
			b.StartTimer()
		}
	}
}