package server

import (
	"fmt"
	"io"
	"net"

	"httpfromtcp/internal/response"
	"httpfromtcp/internal/request"
)

type HandlerError struct{
	StatusCode response.StatusCode
	Message string
}

type Handler func(w *response.Writer, req *request.Request)

type Server struct {
	Closed bool
	Handler Handler
}

func runConnection(s *Server, conn io.ReadWriteCloser) {
	defer conn.Close()

	responseWriter := response.NewWriter(conn)
	headers := response.GetDefaultHeaders(0)
	r,err:= request.RequestFromReader(conn)
	if err != nil{
		responseWriter.WriteStatusLine(response.StatusBadRequest)
		responseWriter.WriteHeaders(*headers)
		return
	}

	s.Handler(responseWriter,r)
}

func runServer(s *Server, listener net.Listener) {
	for {
		conn, err := listener.Accept()

		if s.Closed {
			return
		}

		if err != nil {
			return
		}
		go runConnection(s, conn)
	}
}

func Serve(port uint16, handler Handler) (*Server, error) {
	listener, err := net.Listen("tcp", fmt.Sprintf(":%d", port))
	if err != nil {
		return nil, err
	}
	server := &Server{
		Closed: false,
		Handler: handler,
	}
	go runServer(server, listener)

	return server, nil
}

func (s *Server) Close() error {
	s.Closed = true
	return nil
}