package Drivers

import (
	"AnP/Models"
	"AnP/Utils"
	"context"
	"fmt"
	"mime"
	"net/http"
	"strconv"
	"strings"
)

type HTTPDriver struct {
	anp      Models.AnPModel
	host     string
	port     int16
	server   *http.Server
	listener func(writer http.ResponseWriter, request *http.Request)
	autorun  bool
}

func NewHTTPDriver(anp Models.AnPModel, inputs any) *HTTPDriver {
	mime.AddExtensionType(".js", "application/javascript")

	var server HTTPDriver = HTTPDriver{
		anp: anp,
		host: Utils.Get(anp.Settings.Get([]string{
			"http_driver_host", "http_host", "host",
		}, inputs, Utils.GetPointer[any]("")), Utils.GetPointer("")),
		port: Utils.Get(anp.Settings.Get([]string{
			"http_driver_port", "http_port", "port",
		}, inputs, Utils.GetPointer[any](8080)), Utils.GetPointer[int16](8080)),
		listener: Utils.Get[func(writer http.ResponseWriter, request *http.Request)](anp.Settings.Get([]string{
			"http_driver_listener", "http_listener", "listener",
		}, inputs, nil), nil),
		autorun: Utils.Get(anp.Settings.Get([]string{
			"http_driver_autorun", "http_autorun", "autorun",
		}, inputs, Utils.GetPointer[any](true)), Utils.GetPointer(true)),
	}

	if server.listener == nil {
		server.listener = server.listen
	}

	if server.autorun {
		server.Run()
	}

	return &server
}

func (_self HTTPDriver) listen(writer http.ResponseWriter, request *http.Request) {

	var response map[string]any = _self.anp.Applications.Go(request.Host, strings.ToLower(request.Method), request.RequestURI)
	var response_bytes []byte = []byte{}

	if response["response"] != nil {
		switch value := response["response"].(type) {
		case string:
			response_bytes = []byte(value)
		case []byte:
			response_bytes = value
		}
	}

	writer.Header().Set("Content-Type", Utils.Get[string](response["mime"], nil))
	writer.WriteHeader(Utils.Get[int](response["code"], nil))
	writer.Write(response_bytes)

}

func (_self HTTPDriver) Run() {

	_self.server = &http.Server{
		Addr:    _self.host + ":" + strconv.FormatInt(int64(_self.port), 10),
		Handler: http.HandlerFunc(_self.listener),
	}

	_self.anp.WaitGroup.Add(1)

	go func() {
		if error := _self.server.ListenAndServe(); error != nil {
			fmt.Printf("Error: %v\n", error)
		}
		_self.anp.WaitGroup.Done()
	}()

}

func (_self HTTPDriver) Stop() {

	context_timeout, cancel := context.WithTimeout(context.Background(), 2000)

	defer cancel()

	if _self.server.Shutdown(context_timeout) != nil {
		Models.DebugPrint("PASA SHUTDOWN")
	}

}