package api

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

	"debtik/internal/bridge"
)

func (s *Server) handleBridgeSummary(w http.ResponseWriter, r *http.Request) {
	summary := s.bridgeMgr.GetSummary()
	writeJSON(w, http.StatusOK, summary)
}

// ---------------- Bridges (/interface bridge) ----------------

func (s *Server) handleListBridges(w http.ResponseWriter, r *http.Request) {
	list := s.bridgeMgr.ListBridges()
	writeJSON(w, http.StatusOK, list)
}

func (s *Server) handleSaveBridge(w http.ResponseWriter, r *http.Request) {
	var b bridge.BridgeInstance
	if err := json.NewDecoder(r.Body).Decode(&b); err != nil {
		writeError(w, http.StatusBadRequest, "invalid request body: "+err.Error())
		return
	}
	if err := s.bridgeMgr.SaveBridge(b); err != nil {
		writeError(w, http.StatusInternalServerError, err.Error())
		return
	}
	writeJSON(w, http.StatusOK, map[string]any{"success": true, "id": b.ID})
}

func (s *Server) handleDeleteBridge(w http.ResponseWriter, r *http.Request) {
	id := r.PathValue("id")
	if err := s.bridgeMgr.DeleteBridge(id); err != nil {
		writeError(w, http.StatusInternalServerError, err.Error())
		return
	}
	writeJSON(w, http.StatusOK, map[string]any{"success": true, "id": id})
}

func (s *Server) handleSetBridgeState(w http.ResponseWriter, r *http.Request) {
	id := r.PathValue("id")
	var req struct {
		Disabled bool `json:"disabled"`
	}
	_ = json.NewDecoder(r.Body).Decode(&req)
	if err := s.bridgeMgr.SetBridgeState(id, req.Disabled); err != nil {
		writeError(w, http.StatusInternalServerError, err.Error())
		return
	}
	writeJSON(w, http.StatusOK, map[string]any{"success": true, "id": id, "disabled": req.Disabled})
}

func (s *Server) handleAddBridgeIP(w http.ResponseWriter, r *http.Request) {
	id := r.PathValue("id")
	var req struct {
		IP string `json:"ip"`
	}
	if err := json.NewDecoder(r.Body).Decode(&req); err != nil || req.IP == "" {
		writeError(w, http.StatusBadRequest, "ip address is required")
		return
	}
	if err := s.bridgeMgr.AddBridgeIP(id, req.IP); err != nil {
		writeError(w, http.StatusInternalServerError, err.Error())
		return
	}
	writeJSON(w, http.StatusOK, map[string]any{"success": true, "id": id, "ip": req.IP})
}

func (s *Server) handleDeleteBridgeIP(w http.ResponseWriter, r *http.Request) {
	id := r.PathValue("id")
	var req struct {
		IP string `json:"ip"`
	}
	if err := json.NewDecoder(r.Body).Decode(&req); err != nil || req.IP == "" {
		writeError(w, http.StatusBadRequest, "ip address is required")
		return
	}
	if err := s.bridgeMgr.DeleteBridgeIP(id, req.IP); err != nil {
		writeError(w, http.StatusInternalServerError, err.Error())
		return
	}
	writeJSON(w, http.StatusOK, map[string]any{"success": true, "id": id, "ip": req.IP})
}

// ---------------- Ports (/interface bridge port) ----------------

func (s *Server) handleListBridgePorts(w http.ResponseWriter, r *http.Request) {
	list := s.bridgeMgr.ListPorts()
	writeJSON(w, http.StatusOK, list)
}

func (s *Server) handleSaveBridgePort(w http.ResponseWriter, r *http.Request) {
	var p bridge.BridgePort
	if err := json.NewDecoder(r.Body).Decode(&p); err != nil {
		writeError(w, http.StatusBadRequest, "invalid request body: "+err.Error())
		return
	}
	if err := s.bridgeMgr.SavePort(p); err != nil {
		writeError(w, http.StatusInternalServerError, err.Error())
		return
	}
	writeJSON(w, http.StatusOK, map[string]any{"success": true, "id": p.ID})
}

func (s *Server) handleDeleteBridgePort(w http.ResponseWriter, r *http.Request) {
	id := r.PathValue("id")
	if err := s.bridgeMgr.DeletePort(id); err != nil {
		writeError(w, http.StatusInternalServerError, err.Error())
		return
	}
	writeJSON(w, http.StatusOK, map[string]any{"success": true, "id": id})
}

func (s *Server) handleSetBridgePortState(w http.ResponseWriter, r *http.Request) {
	id := r.PathValue("id")
	var req struct {
		Disabled bool `json:"disabled"`
	}
	_ = json.NewDecoder(r.Body).Decode(&req)
	if err := s.bridgeMgr.SetPortState(id, req.Disabled); err != nil {
		writeError(w, http.StatusInternalServerError, err.Error())
		return
	}
	writeJSON(w, http.StatusOK, map[string]any{"success": true, "id": id, "disabled": req.Disabled})
}

// ---------------- VLANs (/interface bridge vlan) ----------------

func (s *Server) handleListBridgeVLANs(w http.ResponseWriter, r *http.Request) {
	list := s.bridgeMgr.ListVLANs()
	writeJSON(w, http.StatusOK, list)
}

func (s *Server) handleSaveBridgeVLAN(w http.ResponseWriter, r *http.Request) {
	var v bridge.BridgeVLAN
	if err := json.NewDecoder(r.Body).Decode(&v); err != nil {
		writeError(w, http.StatusBadRequest, "invalid request body: "+err.Error())
		return
	}
	if err := s.bridgeMgr.SaveVLAN(v); err != nil {
		writeError(w, http.StatusInternalServerError, err.Error())
		return
	}
	writeJSON(w, http.StatusOK, map[string]any{"success": true, "id": v.ID})
}

func (s *Server) handleDeleteBridgeVLAN(w http.ResponseWriter, r *http.Request) {
	id := r.PathValue("id")
	if err := s.bridgeMgr.DeleteVLAN(id); err != nil {
		writeError(w, http.StatusInternalServerError, err.Error())
		return
	}
	writeJSON(w, http.StatusOK, map[string]any{"success": true, "id": id})
}

func (s *Server) handleSetBridgeVLANState(w http.ResponseWriter, r *http.Request) {
	id := r.PathValue("id")
	var req struct {
		Disabled bool `json:"disabled"`
	}
	_ = json.NewDecoder(r.Body).Decode(&req)
	if err := s.bridgeMgr.SetVLANState(id, req.Disabled); err != nil {
		writeError(w, http.StatusInternalServerError, err.Error())
		return
	}
	writeJSON(w, http.StatusOK, map[string]any{"success": true, "id": id, "disabled": req.Disabled})
}

// ---------------- Hosts / FDB Table (/interface bridge host) ----------------

func (s *Server) handleListBridgeHosts(w http.ResponseWriter, r *http.Request) {
	bridgeName := r.URL.Query().Get("bridge")
	hosts, err := s.bridgeMgr.ListHosts(bridgeName)
	if err != nil {
		writeError(w, http.StatusInternalServerError, err.Error())
		return
	}
	writeJSON(w, http.StatusOK, hosts)
}

func (s *Server) handleFlushBridgeHosts(w http.ResponseWriter, r *http.Request) {
	var req struct {
		Bridge string `json:"bridge"`
	}
	_ = json.NewDecoder(r.Body).Decode(&req)
	if req.Bridge == "" {
		writeError(w, http.StatusBadRequest, "bridge is required")
		return
	}
	if err := s.bridgeMgr.FlushHosts(req.Bridge); err != nil {
		writeError(w, http.StatusInternalServerError, err.Error())
		return
	}
	writeJSON(w, http.StatusOK, map[string]any{"success": true, "bridge": req.Bridge})
}