package tests

// Package tests --
// 1) StartSession              -----
// 2) DestroySessioon           -----
// 3) Set session variable--|
// 4) Get session variable--|
// 5) Update -- // --
// 6) Delete -- // --
// 7) GC session after lifetime
import (
	"fmt"
	"io"
	"net/http"
	"net/http/cookiejar"
	"testing"
	"time"

	"git.mtux.eu/darkgopher/session"

	//all impls imports here ...
	_ "git.mtux.eu/darkgopher/session/storage/memory"
)

const sid = "sid"
const lifet = 180
const testsrvaddr = ":8888"

var sm *session.Manager //current session impl.
var tc *TestClient      //current test client

type TestServer struct {
	addr string
}

func NewTestServer(addr string) (ts *TestServer) {
	return &TestServer{addr}
}

func (ts *TestServer) Serve() {
	http.HandleFunc("/startsession", ts.startSession)     //ck
	http.HandleFunc("/destroysession", ts.destroySession) //ck
	http.HandleFunc("/setsessionvar", ts.setSessionVar)
	http.HandleFunc("/getsessionvar", ts.getSessionVar)
	http.HandleFunc("/updatesessionvar", ts.updateSessionVar)
	http.HandleFunc("/validateupdatedvalue", ts.validateUpdatedValue)
	http.HandleFunc("/deletesessionvalue", ts.deleteSessionValue)
	http.HandleFunc("/validatedeletedvalue", ts.validateDeletedValue)
	http.HandleFunc("/sessionGC", ts.sessionGC) //ck
	http.ListenAndServe(ts.addr, nil)
}

func (ts *TestServer) startSession(w http.ResponseWriter, r *http.Request) {
	var err error
	if _, err = sm.SessionStart(w, r); err != nil {
		io.WriteString(w, err.Error())
	}
	io.WriteString(w, "OK")
}

func (ts *TestServer) destroySession(w http.ResponseWriter, r *http.Request) {
	var err error
	if _, err = sm.SessionStart(w, r); err != nil {
		io.WriteString(w, err.Error())
	}
	if err = sm.SessionDestroy(w, r); err != nil {
		io.WriteString(w, err.Error())
	}
	io.WriteString(w, "OK")
}

func (ts *TestServer) setSessionVar(w http.ResponseWriter, r *http.Request) {
	var err error
	var sess session.Session
	if sess, err = sm.SessionStart(w, r); err != nil {
		io.WriteString(w, err.Error())
	}
	if err = sess.Set("Pes", "Minule"); err != nil {
		io.WriteString(w, err.Error())
	}
	if err = sess.Set("Vek", 16); err != nil {
		io.WriteString(w, err.Error())
	}
	io.WriteString(w, "OK")
}

func (ts *TestServer) getSessionVar(w http.ResponseWriter, r *http.Request) {
	var err error
	var sess session.Session
	if sess, err = sm.SessionStart(w, r); err != nil {
		io.WriteString(w, err.Error())
	}

	var (
		v any
		n any
	)

	if v, err = sess.Get("Pes"); err != nil {
		io.WriteString(w, err.Error())
	}
	if n, err = sess.Get("Vek"); err != nil {
		io.WriteString(w, err.Error())
	}
	if v.(string) != "Minule" {
		fmt.Fprintf(w, "Value of session key: 'Pes' must be 'Minule', not: %s", v)
	}
	if n.(int) != 10 {
		fmt.Fprintf(w, "Value of session key: 'Vek' must be '16', not: %d", n)
	}
	io.WriteString(w, "OK")
}

func (ts *TestServer) updateSessionVar(w http.ResponseWriter, r *http.Request) {
	var err error
	var sess session.Session
	if sess, err = sm.SessionStart(w, r); err != nil {
		io.WriteString(w, err.Error())
	}

	if err = sess.Set("Vek", 3); err != nil {
		io.WriteString(w, err.Error())
	}
	io.WriteString(w, "OK")
}

func (ts *TestServer) validateUpdatedValue(w http.ResponseWriter, r *http.Request) {
	var err error
	var sess session.Session
	if sess, err = sm.SessionStart(w, r); err != nil {
		io.WriteString(w, err.Error())
	}
	fmt.Println(sess)
	var n any
	if n, err = sess.Get("Vek"); err != nil {
		io.WriteString(w, err.Error())
	}
	if n.(int) != 3 {
		io.WriteString(w, fmt.Sprintf("Value vek ater update must be: '3', not: '%d'", n.(int)))
	}
	io.WriteString(w, "OK")
}

func (ts *TestServer) deleteSessionValue(w http.ResponseWriter, r *http.Request) {
	var err error
	var sess session.Session
	if sess, err = sm.SessionStart(w, r); err != nil {
		io.WriteString(w, err.Error())
	}
	if sess.Delete("Vek"); err != nil {
		io.WriteString(w, err.Error())
	}
	io.WriteString(w, "OK")
}

func (ts *TestServer) validateDeletedValue(w http.ResponseWriter, r *http.Request) {
	var err error
	var sess session.Session
	if sess, err = sm.SessionStart(w, r); err != nil {
		io.WriteString(w, err.Error())
	}
	var v any
	if v, err = sess.Get("Vek"); err != nil {
		io.WriteString(w, err.Error())
	}
	if v != nil {
		io.WriteString(w, fmt.Sprintf("Session value 'Vek' must be nil after delete, not: %v", v))
	}
	io.WriteString(w, "OK")
}

func (ts *TestServer) sessionGC(w http.ResponseWriter, r *http.Request) {
	var err error
	if _, err = sm.SessionStart(w, r); err != nil {
		io.WriteString(w, err.Error())
	}
	time.Sleep(200 * time.Millisecond)
	io.WriteString(w, "OK")
}

type TestClient struct {
	cl      *http.Client
	ckstore *cookiejar.Jar
}

func NewTestClient() (tc *TestClient, err error) {
	var ckstore *cookiejar.Jar
	if ckstore, err = cookiejar.New(nil); err != nil {
		return nil, err
	}
	httpclient := &http.Client{Jar: ckstore}
	tc = &TestClient{httpclient, ckstore}
	return
}

// Request send http request into test server and return ResponseResult or error
func (tc *TestClient) Request(meth, uri string) (resb []byte, err error) {
	var req *http.Request
	if req, err = http.NewRequest(meth, uri, nil); err != nil {
		return nil, fmt.Errorf("Create request to: %s ailed err: %v", uri, err)
	}
	var rs *http.Response
	if rs, err = tc.cl.Do(req); err != nil {
		return nil, fmt.Errorf("Request failed err: %v", err)
	}

	defer rs.Body.Close()
	var body []byte
	if body, err = io.ReadAll(rs.Body); err != nil {
		return nil, err
	}
	return body, nil
}

func t1(t *testing.T) {
	var res []byte
	var err error
	if res, err = tc.Request("GET", "http://localhost:8080/startsession/"); err != nil {
		t.Logf("err: %v", err)
		t.Error(err)
	}
	if string(res) != "OK" {
		t.Errorf("Response from test request not OK, but: %s", res)
	}
}

func t2(t *testing.T) {}
func t3(t *testing.T) {}
func t4(t *testing.T) {}
func t5(t *testing.T) {}
func t6(t *testing.T) {}
func t7(t *testing.T) {}

// iterate all session storage impls. and run t1 - t7
func TestRunAll(t *testing.T) {
	ts := NewTestServer("localhost:8080")
	ts.Serve()
	for _, pn := range session.ProviderNames() {
		var err error
		tc, err = NewTestClient()
		if sm, err = session.NewManager(pn, sid, lifet, true); err != nil {
			t.Errorf("Session provider %s failed initialize err: %v", pn, err)
		}
		fns := []func(t *testing.T){t1, t2, t3, t4, t5, t6, t7}
		for idx, fn := range fns {
			t.Run(fmt.Sprintf("Test%d", idx+1), fn)
		}
	}
}