package web

import (
	"encoding/json"
	"fmt"
	"net/http"
	"strings"

    "github.com/rs/zerolog/log"
	"code.severnaya.net/kordophone-mock/v2/server"
)

type MockHTTPServerConfiguration struct {
	AuthEnabled bool
}

type MockHTTPServer struct {
	Server      server.Server
	mux         http.ServeMux
	authEnabled bool
}

type AuthError struct {
	message string
}

func (e *AuthError) Error() string {
	return e.message
}

func (m *MockHTTPServer) logRequest(r *http.Request, extras ...string) {
	log.Debug().Msgf("%s %s   %s", r.Method, r.URL.Path, strings.Join(extras, " "))
}

func (m *MockHTTPServer) checkAuthentication(r *http.Request) error {
	if !m.authEnabled {
		return nil
	}

	// Check for Authorization header
	authHeader := r.Header.Get("Authorization")
	if authHeader == "" {
		return &AuthError{"Missing Authorization header"}
	}

	// Check for "Bearer" prefix
	if authHeader[:7] != "Bearer " {
		return &AuthError{"Invalid Authorization header"}
	}

	// Check for valid token
	token := authHeader[7:]
	if !m.Server.CheckBearerToken(token) {
		return &AuthError{"Invalid token"}
	}

	return nil
}

func (m *MockHTTPServer) handleVersion(w http.ResponseWriter, r *http.Request) {
	fmt.Fprintf(w, "%s", m.Server.Version())
}

func (m *MockHTTPServer) handleStatus(w http.ResponseWriter, r *http.Request) {
	if err := m.checkAuthentication(r); err != nil {
		log.Error().Err(err).Msg("Status: Error checking authentication")
		http.Error(w, err.Error(), http.StatusUnauthorized)
		return
	}

	fmt.Fprintf(w, "OK")
}

func (m *MockHTTPServer) handleConversations(w http.ResponseWriter, r *http.Request) {
	convos := m.Server.Conversations()

	// Encode convos as JSON
	jsonData, err := json.Marshal(convos)
	if err != nil {
		log.Error().Err(err).Msg("Error marshalling conversations")
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

	// Write JSON to response
	w.Header().Set("Content-Type", "application/json")
	w.Write(jsonData)
}

func (m *MockHTTPServer) handleMessages(w http.ResponseWriter, r *http.Request) {
	// TODO handle optional "limit", "beforeDate", "beforeMessageGUID", and "afterMessageGUID" parameters

	guid := r.URL.Query().Get("guid")
	if len(guid) == 0 {
		log.Error().Msg("handleMessage: Got empty guid parameter")
		http.Error(w, "no guid parameter specified", http.StatusBadRequest)
		return
	}

	conversation, err := m.Server.ConversationForGUID(guid)
	if err != nil {
		log.Error().Err(err).Msgf("handleMessage: Error getting conversation (%s)", guid)
		http.Error(w, "conversation not found", http.StatusBadRequest)
		return
	}

	messages := m.Server.MessagesForConversation(*conversation)

	jsonData, err := json.Marshal(messages)
	if err != nil {
		log.Error().Err(err).Msg("Error marshalling messages")
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

	// Write JSON to response
	w.Header().Set("Content-Type", "application/json")
	w.Write(jsonData)
}

func (m *MockHTTPServer) handleAuthenticate(w http.ResponseWriter, r *http.Request) {
	// Decode request body as AuthenticationRequest
	var authReq AuthenticationRequest
	err := json.NewDecoder(r.Body).Decode(&authReq)
	if err != nil {
		log.Error().Err(err).Msg("Authenticate: Error decoding request body")
		http.Error(w, err.Error(), http.StatusBadRequest)
		return
	}

	// Authenticate
	token, err := m.Server.Authenticate(authReq.Username, authReq.Password)
	if err != nil {
		log.Error().Err(err).Msg("Authenticate: Error authenticating")
		http.Error(w, err.Error(), http.StatusUnauthorized)
		return
	}

	// Write response
	w.Header().Set("Content-Type", "application/json")

	// Encode token as JSON
	jsonData, err := json.Marshal(token)
	if err != nil {
		log.Error().Err(err).Msg("Error marshalling token")
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

	// Write JSON to response
	w.Write(jsonData)
}

func (m *MockHTTPServer) handleNotFound(w http.ResponseWriter, r *http.Request) {
	log.Error().Msgf("Unimplemented API endpoint: %s %s", r.Method, r.URL.Path)
	http.NotFound(w, r)
}

func (m *MockHTTPServer) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	m.logRequest(r, r.URL.Query().Encode())
	m.mux.ServeHTTP(w, r)
}

func NewMockHTTPServer(config MockHTTPServerConfiguration) *MockHTTPServer {
	this := MockHTTPServer{
		Server:      *server.NewServer(),
		mux:         *http.NewServeMux(),
		authEnabled: config.AuthEnabled,
	}

	this.mux.Handle("/version", http.HandlerFunc(this.handleVersion))
	this.mux.Handle("/conversations", http.HandlerFunc(this.handleConversations))
	this.mux.Handle("/status", http.HandlerFunc(this.handleStatus))
	this.mux.Handle("/authenticate", http.HandlerFunc(this.handleAuthenticate))
	this.mux.Handle("/messages", http.HandlerFunc(this.handleMessages))
	this.mux.Handle("/", http.HandlerFunc(this.handleNotFound))

	return &this
}