"use client"; // components/modales/KueModal.jsx
import ReactModal from "react-modal";
import { useState, useEffect } from "react";
import { useSelector, useDispatch } from "react-redux";
import { setVariables } from "../../../../redux/slices/variablesSlice";
import "bootstrap-icons/font/bootstrap-icons.css"; // Import Bootstrap Icons
import handleSave, { OriginalValues } from "./handlers/handleSave";
import handleDisplayEinschalten from "./handlers/handleDisplayEinschalten";
import handleChange from "./handlers/handleChange";
import firmwareUpdate from "./handlers/firmwareUpdate";
import decodeToken from "../../../../utils/decodeToken";
// Props-Typen definieren
interface KueModalProps {
  showModal: boolean;
  onClose: () => void;
  slot: number;
  onModulNameChange: (id: string) => void;
}

function KueModal({
  showModal,
  onClose,
  slot,
  onModulNameChange,
}: KueModalProps): JSX.Element {
  const isAdminLoggedIn = useSelector(
    (state: any) => state.auth.isAdminLoggedIn
  );
  const [isAdmin, setIsAdmin] = useState(false);
  const dispatch = useDispatch();
  const [ids, setIds] = useState(Array(32).fill(""));
  const [bezeichnungen, setBezeichnungen] = useState(Array(32).fill(""));
  const [isolationsgrenzwerte, setIsolationsgrenzwerte] = useState(
    Array(32).fill(10.0)
  );
  const [verzoegerung, setVerzoegerung] = useState(Array(32).fill(1.0));
  const [untereSchleifenGrenzwerte, setUntereSchleifenGrenzwerte] = useState(
    Array(32).fill(0.1)
  );
  const [obereSchleifenGrenzwerte, setObereSchleifenGrenzwerte] = useState(
    Array(32).fill(1.0)
  );
  const [schleifenintervall, setSchleifenintervall] = useState(
    Array(32).fill(24)
  );

  const [originalValues, setOriginalValues] = useState<OriginalValues>({
    kueID: Array(32).fill(""),
    kueBezeichnungen: Array(32).fill(""),
    isolationsgrenzwerte: Array(32).fill(10.0),
    verzoegerung: Array(32).fill(1.0),
    untereSchleifenGrenzwerte: Array(32).fill(0.1),
    obereSchleifenGrenzwerte: Array(32).fill(1.0),
    schleifenintervall: Array(32).fill(24),
  });

  // Werte aus dem Redux-Store abrufen
  const {
    kueID,
    kueLimit1,
    kueDelay1,
    kueLimit2Low,
    kueLimit2High,
    kueLoopInterval,
  } = useSelector((state: any) => state.kueData);

  const handleSaveWrapper = () => {
    handleSave({
      ids,
      bezeichnungen,
      isolationsgrenzwerte,
      verzoegerung,
      untereSchleifenGrenzwerte,
      obereSchleifenGrenzwerte,
      schleifenintervall,
      originalValues,
      slot,
      dispatch,
      onModulNameChange,
      onClose,
    });
  };

  const handleDisplayEinschaltenWrapper = () => {
    handleDisplayEinschalten(slot); // Übergebe den Slot als Parameter
  };
  //------------------------------------------------------------------------------------------------------------
  // Initiale Werte festlegen, nur einmal beim Öffnen des Modals
  useEffect(() => {
    if (showModal) {
      setIds(kueID ? kueID.map((id: string) => id.trim() || "---") : ids);
      setBezeichnungen(
        kueID
          ? kueID.map((name: string) => name.trim() || "---")
          : bezeichnungen
      );
      setIsolationsgrenzwerte(kueLimit1 || isolationsgrenzwerte);
      setVerzoegerung(kueDelay1 || verzoegerung);
      setUntereSchleifenGrenzwerte(kueLimit2Low || untereSchleifenGrenzwerte);
      setObereSchleifenGrenzwerte(kueLimit2High || obereSchleifenGrenzwerte);
      setSchleifenintervall(kueLoopInterval || schleifenintervall);

      setOriginalValues({
        kueID: [...ids],
        kueBezeichnungen: [...bezeichnungen],
        isolationsgrenzwerte: [...isolationsgrenzwerte],
        verzoegerung: [...verzoegerung],
        untereSchleifenGrenzwerte: [...untereSchleifenGrenzwerte],
        obereSchleifenGrenzwerte: [...obereSchleifenGrenzwerte],
        schleifenintervall: [...schleifenintervall],
      });
    }
  }, [showModal]); // nur von showModal abhängig ansonsten wird alle 10 Sekunden die Werte zurückgesetzt in Modal
  //------------------------------------------------------------------------------------------------------------
  useEffect(() => {
    const token = sessionStorage.getItem("token");
    if (token) {
      const decoded = decodeToken(token);
      if (decoded && decoded.role.toLowerCase() === "admin") {
        setIsAdmin(true);
      } else {
        setIsAdmin(false);
      }
    }
  }, [showModal]);

  //------------------------------------------------------------------------------------------------------------
  return (
    <ReactModal
      isOpen={showModal}
      onRequestClose={onClose}
      ariaHideApp={false}
      style={{
        overlay: {
          backgroundColor: "rgba(0, 0, 0, 0.5)",
          zIndex: 100,
        },
        content: {
          top: "50%",
          left: "50%",
          right: "auto",
          bottom: "auto",
          marginRight: "-50%",
          transform: "translate(-50%, -50%)",
          width: "90%",
          maxWidth: "800px",
          padding: "10px",
          borderRadius: "8px",
          border: "none",
        },
      }}
    >
      <div className="flex items-center justify-between bg-littwin-blue text-white p-1 rounded-t-lg">
        <h2 className="text-sm font-bold">KUE Einstellung - Slot {slot + 1}</h2>
        <button
          onClick={onClose}
          style={{
            position: "absolute",
            top: "10px",
            right: "20px",
            background: "transparent",
            border: "none",
            cursor: "pointer",
            fontSize: "24px",
          }}
        >
          <i className="bi bi-x-circle-fill"></i>
        </button>
      </div>

      <div className="p-2 mb-4 text-black">
        <div className="mb-2 ">
          <label className="font-bold ">Kabelbezeichnung:</label>
          <input
            type="text"
            className="border rounded p-1 w-full text-sm"
            value={ids[slot]}
            onChange={(e) => handleChange(setIds, e, slot)}
          />
        </div>
      </div>

      <div className="p-2 text-black">
        <h3 className="font-bold text-center mb-4">Isolationsmessung</h3>
        <table className="w-full text-left border-collapse mb-4">
          <thead className="bg-gray-100">
            <tr>
              <th className="p-2 border text-sm text-center">
                Grenzwert (MOhm)
              </th>
              <th className="p-2 border text-sm text-center">
                Verzögerung (sek)
              </th>
            </tr>
          </thead>
          <tbody>
            <tr>
              <td className="p-2 border text-center">
                <input
                  type="number"
                  className="w-[6rem] border rounded p-1 text-sm"
                  value={isolationsgrenzwerte[slot]}
                  step="0.1"
                  onChange={(e) =>
                    handleChange(setIsolationsgrenzwerte, e, slot)
                  }
                />
              </td>
              <td className="p-2 border text-center">
                <input
                  type="number"
                  className="w-[6rem] border rounded p-1 text-sm"
                  value={verzoegerung[slot]}
                  step="0.1"
                  onChange={(e) => handleChange(setVerzoegerung, e, slot)}
                />
              </td>
            </tr>
          </tbody>
        </table>

        <h3 className="font-bold text-center mb-4">Schleifenmessung</h3>
        <table className="w-full text-left border-collapse">
          <thead className="bg-gray-100">
            <tr>
              <th className="p-2 border text-sm text-center">
                Grenzwert (kOhm)
              </th>
              <th className="p-2 border text-sm text-center">
                Schleifenintervall (h)
              </th>
            </tr>
          </thead>
          <tbody>
            <tr>
              <td className="p-2 border text-center">
                <input
                  type="number"
                  className="w-[6rem] border rounded p-1 text-sm"
                  value={untereSchleifenGrenzwerte[slot]}
                  step="0.1"
                  onChange={(e) =>
                    handleChange(setUntereSchleifenGrenzwerte, e, slot)
                  }
                />
              </td>
              <td className="p-2 border text-center">
                <input
                  type="number"
                  className="w-[6rem] border rounded p-1 text-sm"
                  value={schleifenintervall[slot]}
                  step="1"
                  onChange={(e) => handleChange(setSchleifenintervall, e, slot)}
                />
              </td>
            </tr>
          </tbody>
        </table>
      </div>

      <div className="flex justify-end bg-gray-100 p-4 rounded-b-lg">
        {/* Bedingte Anzeige der Firmware-Update-Schaltfläche */}
        {isAdminLoggedIn && (
          <button
            onClick={() => firmwareUpdate(slot)}
            className="bg-littwin-blue text-white p-2 rounded flex items-center mr-2"
          >
            Firmware Update
          </button>
        )}
        <button
          onClick={handleDisplayEinschaltenWrapper}
          className="bg-littwin-blue text-white p-2 rounded flex items-center mr-2"
        >
          <span className="mr-2">📺</span> Display einschalten
        </button>
        <button
          onClick={handleSaveWrapper}
          className="bg-littwin-blue text-white p-2 rounded flex items-center"
        >
          <span className="mr-2">💾</span> Speichern
        </button>
      </div>
    </ReactModal>
  );
}

export default KueModal;
