// components/modales/kueModal/handlers/handleSave.ts
import { setKueData } from "../../../../../redux/slices/kueDataSlice";

export interface OriginalValues {
  kueID: string[];
  kueName: string[];
  isolationsgrenzwerte: number[];
  verzoegerung: number[];
  untereSchleifenGrenzwerte: number[];
  obereSchleifenGrenzwerte: number[];
  schleifenintervall: number[];
  speicherintervall: number[];
}

export interface HandleSaveParams {
  ids: string[];
  kueName: string[];
  isolationsgrenzwerte: number[];
  verzoegerung: number[];
  untereSchleifenGrenzwerte: number[];
  obereSchleifenGrenzwerte: number[];
  schleifenintervall: number[];
  speicherintervall: number[];
  originalValues: {
    kueID: string[];
    kueName: string[];
    isolationsgrenzwerte: number[];
    verzoegerung: number[];
    untereSchleifenGrenzwerte: number[];
    obereSchleifenGrenzwerte: number[];
    schleifenintervall: number[];
    speicherintervall: number[];
  };
  slot: number;
  dispatch: import("redux").Dispatch;
  onModulNameChange: (id: string) => void;
  onClose: () => void;
  onFormUpdate?: (updated: Record<string, unknown>) => void; // Specify a more precise type instead of 'any'
}

const isDifferent = (a: unknown, b: unknown): boolean => {
  const aNum = Number(a);
  const bNum = Number(b);
  if (!isNaN(aNum) && !isNaN(bNum)) {
    return Math.abs(aNum - bNum) > 0.0001;
  }
  return String(a).trim() !== String(b).trim();
};

const handleSave = async ({
  ids,
  kueName,
  isolationsgrenzwerte,
  verzoegerung,
  untereSchleifenGrenzwerte,
  obereSchleifenGrenzwerte,
  schleifenintervall,
  speicherintervall,
  originalValues,
  slot,
  dispatch,
  onModulNameChange,
  onClose,
}: HandleSaveParams): Promise<void> => {
  const changesForFile: Record<string, string | number> = {};

  if (isDifferent(ids[slot], originalValues.kueID[slot])) {
    changesForFile.KID = ids[slot];
  }

  if (isDifferent(kueName[slot], originalValues.kueName[slot])) {
    changesForFile.KIA = kueName[slot];
  }

  if (
    isDifferent(
      isolationsgrenzwerte[slot],
      originalValues.isolationsgrenzwerte[slot]
    )
  ) {
    changesForFile.KL_ = isolationsgrenzwerte[slot];
  }
  if (isDifferent(verzoegerung[slot], originalValues.verzoegerung[slot])) {
    changesForFile.KD_ = verzoegerung[slot];
  }
  if (
    isDifferent(
      untereSchleifenGrenzwerte[slot],
      originalValues.untereSchleifenGrenzwerte[slot]
    )
  ) {
    changesForFile.KR_ = untereSchleifenGrenzwerte[slot];
  }
  if (
    isDifferent(
      obereSchleifenGrenzwerte[slot],
      originalValues.obereSchleifenGrenzwerte[slot]
    )
  ) {
    changesForFile.KRO_ = obereSchleifenGrenzwerte[slot];
  }
  if (
    isDifferent(
      schleifenintervall[slot],
      originalValues.schleifenintervall[slot]
    )
  ) {
    changesForFile.KRI = schleifenintervall[slot];
  }
  if (
    isDifferent(speicherintervall[slot], originalValues.speicherintervall[slot])
  ) {
    changesForFile.KLO = speicherintervall[slot];
  }

  if (Object.keys(changesForFile).length > 0) {
    const isDev = window.location.hostname === "localhost";
    const isProd = !isDev;

    if (isDev) {
      const keyMap: Record<string, string> = {
        KID: "win_kueID",
        KIA: "win_kueName",
        KL_: "win_kueLimit1",
        KD_: "win_kueDelay1",
        KR_: "win_kueLimit2Low",
        KRO_: "win_kueLimit2High",
        KRI: "win_kueLoopInterval",
        KLO: "win_memoryInterval",
      };

      for (const [key, value] of Object.entries(changesForFile)) {
        const mappedKey = keyMap[key] ?? key;

        const params = new URLSearchParams({
          key: mappedKey,
          value: String(value),
          slot: String(slot),
        });

        const response = await fetch(
          `/api/cpl/updateKueSettingsDataAPIHandler?${params.toString()}`
        );

        if (!response.ok) {
          console.error("DEV fetch error:", await response.text());
        }
      }
    }

    if (isProd) {
      try {
        for (const [key, value] of Object.entries(changesForFile)) {
          const singleParam = `${key}${slot}=${encodeURIComponent(value)}`;
          const url = `/CPL?/kabelueberwachung.html&${singleParam}`;

          console.log("📡 Sende an CPL (CGI) →", url);

          const response = await fetch(url);
          if (!response.ok) {
            alert(`❌ Fehler beim Senden an die CPL-Hardware: ${key}`);
            return;
          }
        }

        alert("✅ Alle Daten erfolgreich an die CPL-Hardware gesendet!");
      } catch (error) {
        console.error("❌ Netzwerkfehler beim CPL-Aufruf:", error);
        alert("❌ Netzwerkfehler beim Senden an die CPL-Hardware");
        return;
      }
    }

    onModulNameChange(ids[slot]);

    dispatch(
      setKueData({
        kueID: [...ids],
        kueName: [...kueName],
        isolationsgrenzwerte: [...isolationsgrenzwerte],
        verzoegerung: [...verzoegerung],
        untereSchleifenGrenzwerte: [...untereSchleifenGrenzwerte],
        obereSchleifenGrenzwerte: [...obereSchleifenGrenzwerte],
        schleifenintervall: [...schleifenintervall],
        memoryInterval: [...speicherintervall],
      })
    );
    // 🚀 Modal erst schließen, wenn UI aktualisiert ist
    setTimeout(() => {
      onClose();
    }, 0);
  } else {
    alert("ℹ️ Keine Änderungen vorgenommen.");
  }

  onClose();
};

export default handleSave;