package server

import (
	"api/internal/browser"
	"encoding/json"
	"log"
	"net/http"

	"fmt"
	"time"

	"github.com/go-chi/chi/v5"
	"github.com/go-chi/chi/v5/middleware"
	"github.com/go-chi/cors"
	"github.com/google/uuid"

	"github.com/coder/websocket"
)

func (s *Server) RegisterRoutes() http.Handler {
	r := chi.NewRouter()
	r.Use(middleware.Logger)

	r.Use(cors.Handler(cors.Options{
		AllowedOrigins:   []string{"*"},
		AllowedMethods:   []string{"GET", "POST", "PUT", "DELETE", "OPTIONS", "PATCH"},
		AllowedHeaders:   []string{"Accept", "Authorization", "Content-Type", "X-CSRF-Token", "Upgrade", "Connection", "Sec-WebSocket-Key", "Sec-WebSocket-Version", "Sec-WebSocket-Extensions", "Sec-WebSocket-Protocol"},
		ExposedHeaders:   []string{"Link", "Upgrade", "Connection", "Sec-WebSocket-Accept"},
		AllowCredentials: true,
		MaxAge:           300,
	}))

	r.Get("/", s.HelloWorldHandler)

	r.Get("/health", s.healthHandler)

	r.Get("/websocket", s.websocketHandler)

	r.Route("/api/browser", func(r chi.Router) {
		r.Get("/sessions", s.listBrowserSessions)
		r.Post("/sessions", s.createBrowserSession)
		r.Route("/sessions/{sessionID}", func(r chi.Router) {
			r.Get("/", s.getBrowserSession)
			r.Delete("/", s.stopBrowserSession)
			r.Get("/vnc", s.browserVNCProxy)
		})
	})

	return r
}

func (s *Server) HelloWorldHandler(w http.ResponseWriter, r *http.Request) {
	resp := make(map[string]string)
	resp["message"] = "Hello World"

	jsonResp, err := json.Marshal(resp)
	if err != nil {
		log.Fatalf("error handling JSON marshal. Err: %v", err)
	}

	_, _ = w.Write(jsonResp)
}

func (s *Server) healthHandler(w http.ResponseWriter, r *http.Request) {
	jsonResp, _ := json.Marshal(s.db.Health())
	_, _ = w.Write(jsonResp)
}

func (s *Server) websocketHandler(w http.ResponseWriter, r *http.Request) {
	socket, err := websocket.Accept(w, r, nil)

	if err != nil {
		log.Printf("could not open websocket: %v", err)
		_, _ = w.Write([]byte("could not open websocket"))
		w.WriteHeader(http.StatusInternalServerError)
		return
	}

	defer socket.Close(websocket.StatusGoingAway, "server closing websocket")

	ctx := r.Context()
	socketCtx := socket.CloseRead(ctx)

	for {
		payload := fmt.Sprintf("server timestamp: %d", time.Now().UnixNano())
		err := socket.Write(socketCtx, websocket.MessageText, []byte(payload))
		if err != nil {
			break
		}
		time.Sleep(time.Second * 2)
	}
}

func (s *Server) listBrowserSessions(w http.ResponseWriter, r *http.Request) {
	sessions, err := s.browserService.ListSessions(r.Context())
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
	json.NewEncoder(w).Encode(sessions)
}

func (s *Server) createBrowserSession(w http.ResponseWriter, r *http.Request) {
	session, err := s.browserService.StartSession(r.Context())
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
	w.WriteHeader(http.StatusCreated)
	json.NewEncoder(w).Encode(session)
}

func (s *Server) getBrowserSession(w http.ResponseWriter, r *http.Request) {
	sessionID, err := uuid.Parse(chi.URLParam(r, "sessionID"))
	if err != nil {
		http.Error(w, "invalid session ID", http.StatusBadRequest)
		return
	}

	session, err := s.browserService.GetSession(r.Context(), sessionID)
	if err != nil {
		http.Error(w, err.Error(), http.StatusNotFound)
		return
	}
	json.NewEncoder(w).Encode(session)
}

func (s *Server) stopBrowserSession(w http.ResponseWriter, r *http.Request) {
	sessionID, err := uuid.Parse(chi.URLParam(r, "sessionID"))
	if err != nil {
		http.Error(w, "invalid session ID", http.StatusBadRequest)
		return
	}

	if err := s.browserService.StopSession(r.Context(), sessionID); err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
	w.WriteHeader(http.StatusNoContent)
}

func (s *Server) browserVNCProxy(w http.ResponseWriter, r *http.Request) {
	log.Printf("VNC proxy request received from %s", r.RemoteAddr)
	log.Printf("Headers: %v", r.Header)

	sessionID, err := uuid.Parse(chi.URLParam(r, "sessionID"))
	if err != nil {
		log.Printf("Invalid session ID: %v", err)
		http.Error(w, "invalid session ID", http.StatusBadRequest)
		return
	}

	log.Printf("Getting session for ID: %s", sessionID)
	session, err := s.browserService.GetSession(r.Context(), sessionID)
	if err != nil {
		log.Printf("Failed to get session: %v", err)
		http.Error(w, err.Error(), http.StatusNotFound)
		return
	}

	// Add WebSocket upgrade options
	upgradeOptions := &websocket.AcceptOptions{
		InsecureSkipVerify: true,
	}

	log.Printf("Attempting WebSocket upgrade")
	ws, err := websocket.Accept(w, r, upgradeOptions)
	if err != nil {
		log.Printf("WebSocket upgrade failed: %v", err)
		log.Printf("Request headers: %v", r.Header)
		http.Error(w, "could not upgrade to websocket", http.StatusInternalServerError)
		return
	}
	defer ws.Close(websocket.StatusInternalError, "")

	log.Printf("Creating VNC proxy for session %s", sessionID)
	proxy := browser.NewVNCProxy(session)
	if err := proxy.ServeWebSocket(r.Context(), ws); err != nil {
		log.Printf("VNC proxy error for session %s: %v", sessionID, err)
	}
}