package main

import (
	"bufio"
	"context"
	"encoding/base64"
	"encoding/json"
	"fmt"
	"html/template"
	"io/ioutil"
	"log"
	"math"
	"net"
	"net/http"
	"os"
	"path/filepath"
	"regexp"
	"runtime"
	"strconv"
	"strings"
	"sync"
	"time"

	"github.com/gorilla/websocket"
)

type Bridge struct {
	server *http.Server
	port   string
	key    string
	mu     sync.Mutex
	log    func(string) // Callback to log to frontend

	// Log related
	logFileMu sync.Mutex
	logServer *http.Server
	logPort   int

	// Connection tracking
	clientCount   int
	countMu       sync.Mutex
	onCountChange func(int) // Callback to update frontend
	conns         map[*websocket.Conn]bool

	// Restart callback
	onRestart       func()
	onReload        func()
	onClientConnect func(string)

	// Remote forwarding
	remoteMu                sync.Mutex
	remoteStop              chan struct{}
	remoteWg                sync.WaitGroup
	remoteCfg               RemoteConfig
	remoteConn              *websocket.Conn
	remoteStatus            RemoteForwarderStatus
	forwarderStatusProvider func() RemoteForwarderStatus
	forwarderConnect        func()
	forwarderDisconnect     func()
}

func NewBridge() *Bridge {
	b := &Bridge{
		port:  "1122",
		key:   "",
		conns: make(map[*websocket.Conn]bool),
	}
	b.ensureLogDir()
	return b
}

func (b *Bridge) SetLogger(logger func(string)) {
	b.log = logger
}

func (b *Bridge) SetCountCallback(cb func(int)) {
	b.onCountChange = cb
}

func (b *Bridge) SetRestartCallback(cb func()) {
	b.onRestart = cb
}

func (b *Bridge) SetReloadCallback(cb func()) {
	b.onReload = cb
}

func (b *Bridge) SetClientConnectCallback(cb func(string)) {
	b.onClientConnect = cb
}

func (b *Bridge) SetForwarderStatusProvider(cb func() RemoteForwarderStatus) {
	b.forwarderStatusProvider = cb
}

func (b *Bridge) SetForwarderConnectHandler(cb func()) {
	b.forwarderConnect = cb
}

func (b *Bridge) SetForwarderDisconnectHandler(cb func()) {
	b.forwarderDisconnect = cb
}

func (b *Bridge) updateClientCount(delta int) {
	b.countMu.Lock()
	b.clientCount += delta
	count := b.clientCount
	b.countMu.Unlock()

	if b.onCountChange != nil {
		b.onCountChange(count)
	}
}

func (b *Bridge) Log(msg string) {
	timestamp := time.Now().Format("15:04:05")
	entry := fmt.Sprintf("[%s] %s", timestamp, msg)
	if err := b.appendLogLine(entry); err != nil {
		log.Println(entry)
	} else if b.log != nil {
		b.log(msg)
	}
}

func (b *Bridge) GetPrinters() ([]PrinterInfo, error) {
	return b.getPrintersPlatform()
}

type PrinterInfo struct {
	Name      string `json:"name"`
	IsDefault bool   `json:"isDefault"`
}

func (b *Bridge) GetPrinterCapabilities(printerName string) (map[string]interface{}, error) {
	return b.getPrinterCapabilitiesPlatform(printerName)
}

func (b *Bridge) StartServer(port string, key string) error {
	b.mu.Lock()
	defer b.mu.Unlock()

	if b.server != nil {
		return fmt.Errorf("server already running")
	}

	b.port = port
	b.key = key

	mux := http.NewServeMux()
	mux.HandleFunc("/ws", b.handleWebSocket)

	b.server = &http.Server{
		Addr:    ":" + port,
		Handler: mux,
	}

	go func() {
		b.Log(fmt.Sprintf("Starting server on port %s...", port))
		if err := b.server.ListenAndServe(); err != nil && err != http.ErrServerClosed {
			b.Log(fmt.Sprintf("Server error: %v", err))
		}
		b.Log("Server stopped")
	}()

	return nil
}

func (b *Bridge) StopServer() error {
	b.mu.Lock()
	defer b.mu.Unlock()

	if b.server == nil {
		return nil
	}

	// Close all active connections first
	b.countMu.Lock()
	for conn := range b.conns {
		conn.Close()
	}
	// Clear the map
	b.conns = make(map[*websocket.Conn]bool)
	b.countMu.Unlock()

	if err := b.server.Shutdown(context.Background()); err != nil {
		return err
	}
	b.server = nil
	return nil
}

var upgrader = websocket.Upgrader{
	CheckOrigin: func(r *http.Request) bool {
		return true // Allow all origins
	},
}

type PrintRequest struct {
	Printer string `json:"printer"`
	Content string `json:"content"` // Base64 encoded PDF
	Key     string `json:"key"`

	Job struct {
		Name       string `json:"name"`
		Copies     int    `json:"copies"`
		IntervalMs int    `json:"intervalMs"`
	} `json:"job"`
	Pages struct {
		Range string `json:"range"`
		Set   string `json:"set"`
	} `json:"pages"`
	Layout struct {
		Scale       string `json:"scale"`
		Orientation string `json:"orientation"`
	} `json:"layout"`
	Color struct {
		Mode string `json:"mode"`
	} `json:"color"`
	Sides struct {
		Mode string `json:"mode"`
	} `json:"sides"`
	Paper PaperSpec `json:"paper"`
	Tray  struct {
		Bin string `json:"bin"`
	} `json:"tray"`
}

type PaperSpec struct {
	Size string `json:"size"`
}

type PrintOptions struct {
	PageRange   string
	PageSet     string
	Duplex      string
	ColorMode   string
	Paper       string
	Scale       string
	Orientation string
	TrayBin     string
	Copies      int
}

type Response struct {
	Status  string `json:"status"`
	Message string `json:"message"`
}

func (b *Bridge) handleWebSocket(w http.ResponseWriter, r *http.Request) {
	// Authentication check
	if b.key != "" {
		pass := r.URL.Query().Get("key")
		if pass == "" {
			pass = r.URL.Query().Get("password")
		}

		if pass != b.key {
			b.Log(fmt.Sprintf("Authentication failed for %s", r.RemoteAddr))
			http.Error(w, "Unauthorized", http.StatusUnauthorized)
			return
		}
	}

	c, err := upgrader.Upgrade(w, r, nil)
	if err != nil {
		b.Log(fmt.Sprintf("Upgrade error: %v", err))
		return
	}
	defer c.Close()

	b.countMu.Lock()
	b.conns[c] = true
	b.countMu.Unlock()
	b.updateClientCount(1)
	defer func() {
		b.countMu.Lock()
		delete(b.conns, c)
		b.countMu.Unlock()
		b.updateClientCount(-1)
	}()

	b.Log(fmt.Sprintf("Client connected from %s", c.RemoteAddr()))

	if b.onClientConnect != nil {
		b.onClientConnect(c.RemoteAddr().String())
	}

	// Send printer list immediately upon connection
	printers, err := b.GetPrinters()
	if err == nil {
		msg := map[string]interface{}{
			"type": "printer_list",
			"data": printers,
		}
		if jsonBytes, err := json.Marshal(msg); err == nil {
			b.Log(fmt.Sprintf("Sent WS message: %s", string(jsonBytes)))
		}
		c.WriteJSON(msg)
	} else {
		b.Log(fmt.Sprintf("Failed to get printers on connect: %v", err))
		errMsg := fmt.Sprintf("Failed to get printer list: %v", err)
		c.WriteJSON(Response{Status: "error", Message: errMsg})
	}

	for {
		// Read message as raw JSON map first to check type
		var rawMsg map[string]interface{}
		err := c.ReadJSON(&rawMsg)
		if err != nil {
			if websocket.IsUnexpectedCloseError(err, websocket.CloseGoingAway, websocket.CloseAbnormalClosure) {
				b.Log(fmt.Sprintf("Client disconnected: %v", err))
			} else {
				// Normal closure or other error
			}
			break
		}

		if jsonBytes, err := json.Marshal(rawMsg); err == nil {
			b.Log(fmt.Sprintf("Received WS message: %s", string(jsonBytes)))
		}

		// Check message type
		if msgType, ok := rawMsg["type"].(string); ok && msgType == "get_printers" {
			printers, err := b.GetPrinters()
			if err == nil {
				msg := map[string]interface{}{
					"type": "printer_list",
					"data": printers,
				}
				if jsonBytes, err := json.Marshal(msg); err == nil {
					b.Log(fmt.Sprintf("Sent WS message: %s", string(jsonBytes)))
				}
				c.WriteJSON(msg)
			} else {
				resp := Response{Status: "error", Message: fmt.Sprintf("Failed to get printer list: %v", err)}
				if jsonBytes, err := json.Marshal(resp); err == nil {
					b.Log(fmt.Sprintf("Sent WS message: %s", string(jsonBytes)))
				}
				c.WriteJSON(resp)
			}
			continue
		}

		if msgType, ok := rawMsg["type"].(string); ok && msgType == "get_printer_caps" {
			printer, _ := rawMsg["printer"].(string)
			printer = strings.TrimSpace(printer)
			if printer == "" {
				resp := Response{Status: "error", Message: "printer is required"}
				c.WriteJSON(resp)
				continue
			}

			caps, err := b.GetPrinterCapabilities(printer)
			if err != nil {
				b.Log(fmt.Sprintf("Failed to get printer capabilities for '%s': %v", printer, err))
				resp := Response{Status: "error", Message: err.Error()}
				c.WriteJSON(resp)
				continue
			}

			msg := map[string]interface{}{
				"type":    "printer_caps",
				"printer": printer,
				"data":    caps,
			}
			c.WriteJSON(msg)
			continue
		}

		// Handle as PrintRequest (default)
		jsonBody, _ := json.Marshal(rawMsg)
		var req PrintRequest
		if err := json.Unmarshal(jsonBody, &req); err != nil {
			b.Log(fmt.Sprintf("Invalid print request: %v", err))
			resp := Response{Status: "error", Message: "Invalid request format"}
			c.WriteJSON(resp)
			continue
		}

		msg, err := b.processPrintRequest(req)
		if err == nil {
			resp := Response{Status: "success", Message: msg}
			c.WriteJSON(resp)
		} else {
			c.WriteJSON(Response{Status: "error", Message: msg})
		}
	}
}

func (b *Bridge) processPrintRequest(req PrintRequest) (string, error) {
	jobName := strings.TrimSpace(req.Job.Name)

	copies := req.Job.Copies
	if copies <= 0 {
		copies = 1
	}

	intervalMs := req.Job.IntervalMs

	contentToDecode := req.Content
	if strings.HasPrefix(contentToDecode, "data:") {
		if idx := strings.Index(contentToDecode, ","); idx != -1 {
			contentToDecode = contentToDecode[idx+1:]
		}
	}
	decoded, err := base64.StdEncoding.DecodeString(contentToDecode)
	if err != nil {
		b.Log("Error decoding Base64 content")
		return "Invalid Base64 content", fmt.Errorf("invalid base64 content")
	}

	if len(decoded) < 4 || string(decoded[0:4]) != "%PDF" {
		b.Log("Content is not a valid PDF (missing %PDF header)")
		return "Content must be a PDF file", fmt.Errorf("invalid pdf")
	}

	autoPaper := ""
	if strings.TrimSpace(req.Paper.Size) == "" {
		if name, ok := detectPaperFromPDF(decoded); ok {
			autoPaper = name
			b.Log(fmt.Sprintf("Auto paper size detected: %s", name))
		}
	}

	options := PrintOptions{
		PageRange:   strings.TrimSpace(req.Pages.Range),
		PageSet:     strings.TrimSpace(req.Pages.Set),
		Duplex:      strings.TrimSpace(req.Sides.Mode),
		ColorMode:   strings.TrimSpace(req.Color.Mode),
		Paper:       strings.TrimSpace(firstNonEmpty(req.Paper.Size, autoPaper)),
		Scale:       strings.TrimSpace(req.Layout.Scale),
		Orientation: strings.TrimSpace(req.Layout.Orientation),
		TrayBin:     strings.TrimSpace(req.Tray.Bin),
	}

	runCount := 1
	perRunCopies := copies
	if intervalMs > 0 {
		runCount = copies
		perRunCopies = 1
	}
	options.Copies = perRunCopies

	successCount := 0
	var lastErr error

	for i := 0; i < runCount; i++ {
		if i > 0 && intervalMs > 0 {
			time.Sleep(time.Duration(intervalMs) * time.Millisecond)
		}

		err = b.printPDF(req.Printer, jobName, decoded, options)
		if err != nil {
			lastErr = err
			b.Log(fmt.Sprintf("Print error (copy %d): %v", i+1, err))
			break
		} else {
			successCount += perRunCopies
		}
	}

	if successCount == copies {
		b.Log("Print success")
		return "Printed successfully", nil
	}

	msg := fmt.Sprintf("Printed %d/%d copies. Error: %v", successCount, copies, lastErr)
	b.Log(msg)
	return msg, fmt.Errorf("print failed")
}

func firstNonEmpty(values ...string) string {
	for _, value := range values {
		if strings.TrimSpace(value) != "" {
			return value
		}
	}
	return ""
}

var (
	mediaBoxRegex = regexp.MustCompile(`/MediaBox\s*\[\s*([-0-9.]+)\s+([-0-9.]+)\s+([-0-9.]+)\s+([-0-9.]+)\s*\]`)
	cropBoxRegex  = regexp.MustCompile(`/CropBox\s*\[\s*([-0-9.]+)\s+([-0-9.]+)\s+([-0-9.]+)\s+([-0-9.]+)\s*\]`)
)

func detectPaperFromPDF(pdfData []byte) (string, bool) {
	limit := len(pdfData)
	if limit > 5*1024*1024 {
		limit = 5 * 1024 * 1024
	}
	chunk := string(pdfData[:limit])
	match := cropBoxRegex.FindStringSubmatch(chunk)
	if len(match) != 5 {
		match = mediaBoxRegex.FindStringSubmatch(chunk)
	}
	if len(match) != 5 {
		return "", false
	}

	llx, err1 := strconv.ParseFloat(match[1], 64)
	lly, err2 := strconv.ParseFloat(match[2], 64)
	urx, err3 := strconv.ParseFloat(match[3], 64)
	ury, err4 := strconv.ParseFloat(match[4], 64)
	if err1 != nil || err2 != nil || err3 != nil || err4 != nil {
		return "", false
	}

	widthPt := math.Abs(urx - llx)
	heightPt := math.Abs(ury - lly)
	return matchStandardPaper(widthPt, heightPt)
}

type paperSize struct {
	Name string
	Wmm  float64
	Hmm  float64
}

func matchStandardPaper(widthPt, heightPt float64) (string, bool) {
	mmPerPt := 25.4 / 72.0
	widthMm := widthPt * mmPerPt
	heightMm := heightPt * mmPerPt

	if widthMm <= 0 || heightMm <= 0 {
		return "", false
	}

	if widthMm > heightMm {
		widthMm, heightMm = heightMm, widthMm
	}

	standard := []paperSize{
		{Name: "A2", Wmm: 420, Hmm: 594},
		{Name: "A3", Wmm: 297, Hmm: 420},
		{Name: "A4", Wmm: 210, Hmm: 297},
		{Name: "A5", Wmm: 148, Hmm: 210},
		{Name: "A6", Wmm: 105, Hmm: 148},
		{Name: "letter", Wmm: 216, Hmm: 279},
		{Name: "legal", Wmm: 216, Hmm: 356},
		{Name: "tabloid", Wmm: 279, Hmm: 432},
		{Name: "statement", Wmm: 140, Hmm: 216},
	}

	const tolerance = 2.0
	for _, size := range standard {
		if math.Abs(widthMm-size.Wmm) <= tolerance && math.Abs(heightMm-size.Hmm) <= tolerance {
			return size.Name, true
		}
	}

	return "", false
}

func (b *Bridge) printPDF(printerName string, jobName string, pdfData []byte, options PrintOptions) error {
	// 1. Write to temp file
	tmpFile, err := ioutil.TempFile("", "print-dot-*.pdf")
	if err != nil {
		return fmt.Errorf("create temp file failed: %v", err)
	}
	defer os.Remove(tmpFile.Name()) // Clean up on exit

	if _, err := tmpFile.Write(pdfData); err != nil {
		tmpFile.Close()
		return fmt.Errorf("write temp file failed: %v", err)
	}
	tmpFile.Close()
	absPath, _ := filepath.Abs(tmpFile.Name())

	if jobName != "" {
		b.Log(fmt.Sprintf("Printing job '%s': %s to %s", jobName, absPath, printerName))
	} else {
		b.Log(fmt.Sprintf("Printing PDF file: %s to %s", absPath, printerName))
	}

	return b.printPDFPlatform(printerName, absPath, options)
}

func (b *Bridge) StartLogServer() error {
	b.ensureLogDir()
	listener, err := net.Listen("tcp", "localhost:0")
	if err != nil {
		return err
	}
	b.logPort = listener.Addr().(*net.TCPAddr).Port

	mux := http.NewServeMux()
	mux.HandleFunc("/logs", b.handleLogs)
	mux.HandleFunc("/api/logs", b.handleLogsJSON)
	mux.HandleFunc("/api/logs/clear", b.handleClearLogs)
	mux.HandleFunc("/api/restart", b.handleRestartRequest)
	mux.HandleFunc("/api/reload", b.handleReloadRequest)
	mux.HandleFunc("/api/forwarder/status", b.handleForwarderStatus)
	mux.HandleFunc("/api/forwarder/connect", b.handleForwarderConnect)
	mux.HandleFunc("/api/forwarder/disconnect", b.handleForwarderDisconnect)
	mux.HandleFunc("/api/forwarder/stream", b.handleForwarderStream)

	b.logServer = &http.Server{
		Handler: mux,
	}

	go func() {
		if err := b.logServer.Serve(listener); err != nil && err != http.ErrServerClosed {
			b.Log(fmt.Sprintf("Log server error: %v", err))
		}
	}()

	return nil
}

func (b *Bridge) ensureLogDir() {
	logDir, err := b.logDirPath()
	if err != nil {
		return
	}
	_ = os.MkdirAll(logDir, 0755)
	path := filepath.Join(logDir, time.Now().Format("20060102")+".txt")
	if f, err := os.OpenFile(path, os.O_CREATE, 0644); err == nil {
		f.Close()
	}
}

func (b *Bridge) StopLogServer() error {
	if b.logServer == nil {
		return nil
	}
	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
	defer cancel()
	if err := b.logServer.Shutdown(ctx); err != nil {
		_ = b.logServer.Close()
		return err
	}
	b.logServer = nil
	return nil
}

func (b *Bridge) handleLogs(w http.ResponseWriter, r *http.Request) {
	currentLogs, _ := b.readLogLines()

	html := `<!DOCTYPE html>
<html>
<head>
	<title>System Logs - XSL-PrintDot Client</title>
	<meta http-equiv="refresh" content="2">
	<style>
		body { 
			font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif; 
			background: #ffffff; 
			color: #333; 
			padding: 20px; 
			margin: 0;
		}
		h2 { border-bottom: 2px solid #eee; padding-bottom: 10px; margin-top: 0; color: #444; }
		.log-entry { 
			border-bottom: 1px solid #f0f0f0; 
			padding: 8px 0; 
			font-family: Consolas, 'Courier New', monospace;
			font-size: 13px;
		}
		.log-entry:hover { background-color: #f9f9f9; }
		.empty { color: #999; font-style: italic; padding: 20px 0; }
		.status { font-size: 12px; color: #888; margin-top: 5px; }
	</style>
</head>
<body>
	<h2>System Logs</h2>
	<div class="status">Auto-refreshing every 2 seconds</div>
	<div id="logs">
		{{range .}}
		<div class="log-entry">{{.}}</div>
		{{else}}
		<div class="empty">No logs available.</div>
		{{end}}
	</div>
</body>
</html>`

	t, err := template.New("logs").Parse(html)
	if err != nil {
		http.Error(w, "Template error", http.StatusInternalServerError)
		return
	}
	t.Execute(w, currentLogs)
}

func (b *Bridge) handleLogsJSON(w http.ResponseWriter, r *http.Request) {
	currentLogs, _ := b.readLogLines()

	w.Header().Set("Content-Type", "application/json")
	w.Header().Set("Access-Control-Allow-Origin", "*") // Allow child process to fetch
	json.NewEncoder(w).Encode(currentLogs)
}

func (b *Bridge) handleClearLogs(w http.ResponseWriter, r *http.Request) {
	w.Header().Set("Access-Control-Allow-Origin", "*")
	w.Header().Set("Access-Control-Allow-Methods", "POST, OPTIONS")

	if r.Method == http.MethodOptions {
		w.WriteHeader(http.StatusOK)
		return
	}

	if r.Method != http.MethodPost {
		http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
		return
	}

	b.clearLogFile()

	w.WriteHeader(http.StatusOK)
}

func (b *Bridge) logFilePath() (string, error) {
	logDir, err := b.logDirPath()
	if err != nil {
		return "", err
	}
	fileName := time.Now().Format("20060102") + ".txt"
	return filepath.Join(logDir, fileName), nil
}

func (b *Bridge) logDirPath() (string, error) {
	baseDir, err := dataDirPath()
	if err != nil {
		return "", err
	}
	return filepath.Join(baseDir, "logs"), nil
}

func dataDirPath() (string, error) {
	if programData := strings.TrimSpace(os.Getenv("ProgramData")); programData != "" {
		return filepath.Join(programData, "PrintDot"), nil
	}
	if runtime.GOOS == "darwin" {
		if home, err := os.UserHomeDir(); err == nil {
			return filepath.Join(home, "Library", "Application Support", "PrintDot"), nil
		}
	}
	if runtime.GOOS == "linux" {
		if dataHome := strings.TrimSpace(os.Getenv("XDG_DATA_HOME")); dataHome != "" {
			return filepath.Join(dataHome, "PrintDot"), nil
		}
		if home, err := os.UserHomeDir(); err == nil {
			return filepath.Join(home, ".local", "share", "PrintDot"), nil
		}
	}
	if wd, err := os.Getwd(); err == nil {
		return filepath.Join(wd, "PrintDot"), nil
	}
	return "", fmt.Errorf("failed to resolve data directory")
}

func (b *Bridge) appendLogLine(line string) error {
	b.ensureLogDir()
	path, err := b.logFilePath()
	if err != nil {
		return err
	}
	if !strings.HasSuffix(line, "\n") {
		line += "\n"
	}

	b.logFileMu.Lock()
	defer b.logFileMu.Unlock()

	f, err := os.OpenFile(path, os.O_CREATE|os.O_APPEND|os.O_WRONLY, 0644)
	if err != nil {
		return err
	}
	defer f.Close()

	_, err = f.WriteString(line)
	return err
}

func (b *Bridge) readLogLines() ([]string, error) {
	b.ensureLogDir()
	path, err := b.logFilePath()
	if err != nil {
		return nil, err
	}

	b.logFileMu.Lock()
	defer b.logFileMu.Unlock()

	f, err := os.Open(path)
	if err != nil {
		if os.IsNotExist(err) {
			return []string{}, nil
		}
		return nil, err
	}
	defer f.Close()

	lines := []string{}
	scanner := bufio.NewScanner(f)
	for scanner.Scan() {
		text := strings.TrimSpace(scanner.Text())
		if text == "" {
			continue
		}
		lines = append(lines, text)
	}

	if err := scanner.Err(); err != nil {
		return lines, err
	}

	// Reverse logs for display (newest top)
	for i, j := 0, len(lines)-1; i < j; i, j = i+1, j-1 {
		lines[i], lines[j] = lines[j], lines[i]
	}
	return lines, nil
}

func (b *Bridge) clearLogFile() {
	path, err := b.logFilePath()
	if err != nil {
		return
	}

	b.logFileMu.Lock()
	defer b.logFileMu.Unlock()
	_ = os.Remove(path)
}

func (b *Bridge) handleReloadRequest(w http.ResponseWriter, r *http.Request) {
	w.Header().Set("Access-Control-Allow-Origin", "*")
	w.Header().Set("Access-Control-Allow-Methods", "POST, OPTIONS")

	if r.Method == http.MethodOptions {
		w.WriteHeader(http.StatusOK)
		return
	}

	if r.Method != http.MethodPost {
		http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
		return
	}

	w.WriteHeader(http.StatusOK)
	w.Write([]byte("Reload initiated"))

	// Trigger reload on main thread
	if b.onReload != nil {
		go func() {
			time.Sleep(100 * time.Millisecond)
			b.onReload()
		}()
	}
}

func (b *Bridge) handleForwarderStatus(w http.ResponseWriter, r *http.Request) {
	w.Header().Set("Access-Control-Allow-Origin", "*")
	if r.Method != http.MethodGet {
		http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
		return
	}

	status := RemoteForwarderStatus{}
	if b.forwarderStatusProvider != nil {
		status = b.forwarderStatusProvider()
	}

	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(status)
}

func (b *Bridge) handleForwarderConnect(w http.ResponseWriter, r *http.Request) {
	w.Header().Set("Access-Control-Allow-Origin", "*")
	w.Header().Set("Access-Control-Allow-Methods", "POST, OPTIONS")

	if r.Method == http.MethodOptions {
		w.WriteHeader(http.StatusOK)
		return
	}
	if r.Method != http.MethodPost {
		http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
		return
	}

	if b.forwarderConnect != nil {
		b.forwarderConnect()
	}
	w.WriteHeader(http.StatusOK)
}

func (b *Bridge) handleForwarderDisconnect(w http.ResponseWriter, r *http.Request) {
	w.Header().Set("Access-Control-Allow-Origin", "*")
	w.Header().Set("Access-Control-Allow-Methods", "POST, OPTIONS")

	if r.Method == http.MethodOptions {
		w.WriteHeader(http.StatusOK)
		return
	}
	if r.Method != http.MethodPost {
		http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
		return
	}

	if b.forwarderDisconnect != nil {
		b.forwarderDisconnect()
	}
	w.WriteHeader(http.StatusOK)
}

func (b *Bridge) handleForwarderStream(w http.ResponseWriter, r *http.Request) {
	w.Header().Set("Access-Control-Allow-Origin", "*")
	w.Header().Set("Content-Type", "text/event-stream")
	w.Header().Set("Cache-Control", "no-cache")
	w.Header().Set("Connection", "keep-alive")

	flusher, ok := w.(http.Flusher)
	if !ok {
		http.Error(w, "streaming unsupported", http.StatusInternalServerError)
		return
	}

	status := RemoteForwarderStatus{}
	if b.forwarderStatusProvider != nil {
		status = b.forwarderStatusProvider()
	}
	if data, err := json.Marshal(status); err == nil {
		fmt.Fprintf(w, "data: %s\n\n", data)
		flusher.Flush()
	}

	last := status
	ctx := r.Context()
	ticker := time.NewTicker(2 * time.Second)
	defer ticker.Stop()

	for {
		select {
		case <-ctx.Done():
			return
		case <-ticker.C:
			current := RemoteForwarderStatus{}
			if b.forwarderStatusProvider != nil {
				current = b.forwarderStatusProvider()
			}
			if current != last {
				if data, err := json.Marshal(current); err == nil {
					fmt.Fprintf(w, "data: %s\n\n", data)
					flusher.Flush()
					last = current
				}
			}
		}
	}
}