package handlers

import (
	"net/http"
	"strconv"
	"strings"

	"lostcavewireplanner/internal/models"
	"lostcavewireplanner/internal/services"
)

func (h *Handlers) ConnectionModal(w http.ResponseWriter, r *http.Request) {
	portIDStr := r.PathValue("portId")
	portID, err := strconv.ParseInt(portIDStr, 10, 64)
	if err != nil {
		http.Error(w, "invalid port id", http.StatusBadRequest)
		return
	}

	trace, err := services.TraceConnection(h.Store, portID)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

	connTypes, _ := h.Store.ConnectionTypeGetAll()
	if connTypes == nil {
		connTypes = []models.ConnectionType{}
	}

	type ConnectionModalData struct {
		Trace           *services.TraceResult
		ConnectionTypes []models.ConnectionType
		AllPorts        []FlatPort
		Error           string
	}

	allDevices, _ := h.Store.DeviceGetAllUnracked()
	rackedDevicesMap := map[int64]bool{}

	var flatPorts []FlatPort
	addDevicePorts := func(devices []models.Device) {
		for _, d := range devices {
			if rackedDevicesMap[d.ID] {
				continue
			}
			rackedDevicesMap[d.ID] = true
			for _, p := range d.Ports {
				flatPorts = append(flatPorts, FlatPort{
					ID:          p.ID,
					Name:        p.Name,
					Side:        p.Side,
					DeviceID:    d.ID,
					DeviceName:  d.Name,
					DeviceModel: "",
				})
				if d.Model != nil {
					flatPorts[len(flatPorts)-1].DeviceModel = d.Model.Name
				}
			}
		}
	}

	addDevicePorts(allDevices)
	for _, rack := range h.mustGetAllRacks() {
		if devs, err := h.Store.DeviceGetByRackID(rack.ID); err == nil {
			addDevicePorts(devs)
		}
		if devs, err := h.Store.DeviceGetUnrackedByRackID(rack.ID); err == nil {
			addDevicePorts(devs)
		}
	}

	h.render(w, "connection_modal.html", ConnectionModalData{
		Trace:           trace,
		ConnectionTypes: connTypes,
		AllPorts:        flatPorts,
	})
}

type FlatPort struct {
	ID          int64
	Name        string
	Side        string
	DeviceID    int64
	DeviceName  string
	DeviceModel string
}

func (h *Handlers) mustGetAllRacks() []models.Rack {
	racks, _ := h.Store.RackGetAll()
	if racks == nil {
		return []models.Rack{}
	}
	return racks
}

func (h *Handlers) ConnectionCreate(w http.ResponseWriter, r *http.Request) {
	r.ParseForm()

	connTypeID, _ := strconv.ParseInt(r.FormValue("connection_type_id"), 10, 64)
	portID1Str := r.FormValue("port_id_1")
	portID2Str := r.FormValue("port_id_2")
	label1 := r.FormValue("label_1")
	label2 := r.FormValue("label_2")
	color := r.FormValue("color")
	returnPortID := r.FormValue("return_port_id")

	if color == "" {
		color = "#808080"
	}

	var p1, p2 *int64
	if portID1Str != "" {
		v, _ := strconv.ParseInt(portID1Str, 10, 64)
		p1 = &v
	}
	if portID2Str != "" {
		v, _ := strconv.ParseInt(portID2Str, 10, 64)
		p2 = &v
	}

	var label1Ptr, label2Ptr *string
	if label1 != "" {
		label1Ptr = &label1
	}
	if label2 != "" {
		label2Ptr = &label2
	}

	conn := &models.Connection{
		ConnectionTypeID: connTypeID,
		Label1:           label1Ptr,
		Label2:           label2Ptr,
		Color:            color,
		PortID1:          p1,
		PortID2:          p2,
	}

	if err := h.Store.ConnectionCreate(conn); err != nil {
		h.redirect(w, r, "/connections/"+returnPortID)
		return
	}

	if returnPortID != "" {
		h.redirect(w, r, "/connections/"+returnPortID)
		return
	}
	h.redirect(w, r, "/")
}

func (h *Handlers) ConnectionEdit(w http.ResponseWriter, r *http.Request) {
	idStr := r.PathValue("id")
	id, _ := strconv.ParseInt(idStr, 10, 64)
	r.ParseForm()

	conn, err := h.Store.ConnectionGetByID(id)
	if err != nil || conn == nil {
		http.Error(w, "connection not found", http.StatusNotFound)
		return
	}

	connTypeID, _ := strconv.ParseInt(r.FormValue("connection_type_id"), 10, 64)
	label1 := r.FormValue("label_1")
	label2 := r.FormValue("label_2")
	color := r.FormValue("color")
	returnPortID := r.FormValue("return_port_id")

	if color == "" {
		color = "#808080"
	}

	conn.ConnectionTypeID = connTypeID
	if label1 != "" {
		conn.Label1 = &label1
	} else {
		conn.Label1 = nil
	}
	if label2 != "" {
		conn.Label2 = &label2
	} else {
		conn.Label2 = nil
	}
	conn.Color = color

	if err := h.Store.ConnectionUpdate(conn); err != nil {
		if returnPortID != "" {
			h.redirect(w, r, "/connections/"+returnPortID)
			return
		}
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

	if returnPortID != "" {
		h.redirect(w, r, "/connections/"+returnPortID)
		return
	}
	h.redirect(w, r, "/")
}

func (h *Handlers) ConnectionDelete(w http.ResponseWriter, r *http.Request) {
	idStr := r.PathValue("id")
	id, _ := strconv.ParseInt(idStr, 10, 64)
	returnPortID := r.URL.Query().Get("return_port_id")

	h.Store.ConnectionDelete(id)

	if returnPortID != "" {
		h.redirect(w, r, "/connections/"+returnPortID)
		return
	}
	h.redirect(w, r, "/")
}

func (h *Handlers) ConnectionGetByID(id int64) (*models.Connection, error) {
	conn, err := h.Store.ConnectionGetByID(id)
	return conn, err
}

func lower(s string) string { return strings.ToLower(s) }