import { useEffect, useState } from 'react';

import { LogicForm, NextTask } from './types';
import { getDyns, getLogics } from './requests';
import axios from 'B/axios';

type UseLogics = [
  LogicForm[],
  React.Dispatch<React.SetStateAction<LogicForm[]>>
];

const createNewField = (order: number): LogicForm => {
  return {
    id: null,
    order: order,
    condition: '',
    value: '',
    next_task_id: '',
    status: 'new',
    conditions: []
  };
};
const _onChange = (useLogics: UseLogics) => (
  rowIndex: number,
  conditionIndex: number,
  key: string,
  directValue = null
) => (e) => {
  const [logics, setLogics] = useLogics;
  const value = directValue !== null ? directValue : e.target.value;
  const updatedLogics = [...logics];

  if (conditionIndex === -1) {
    // Aktualisierung für die Hauptreihe
    updatedLogics[rowIndex][key] = value;

    // Prüfen, ob dies die letzte Hauptreihe ist und ein neuer Eintrag hinzugefügt werden sollte
    if (rowIndex === logics.length - 1 && key === 'condition' && value !== '') {
      // Neue Hauptreihe hinzufügen, wenn die Bedingung in der letzten Reihe ausgefüllt wurde
      updatedLogics.push(createNewField(logics.length));
    }
  } else {
    // Aktualisierung für Subrows (conditions)
    const conditions = updatedLogics[rowIndex].conditions || [];
    if (conditions[conditionIndex] !== undefined) {
      conditions[conditionIndex] = {
        ...conditions[conditionIndex],
        [key]: value,
      };
      updatedLogics[rowIndex].conditions = conditions;
    }
  }

  setLogics(updatedLogics);
};

const _onDelete = (useLogics: UseLogics, useToDelete) => (index) => () => {
  const [logics, setLogics] = useLogics;
  const logicIDToDelete = logics[index].id;

  logics.splice(index, 1);
  setLogics([...logics]);

  if (logicIDToDelete === null) {
    return;
  }

  const [toDelete, setToDelete] = useToDelete;
  setToDelete([...toDelete, logicIDToDelete]);
};

const _onClickUp = (useLogics: UseLogics) => (index: number) => () => {
  const [logics, setLogics] = useLogics;

  const logicToMove = logics[index];
  const logicToReplace = logics[index - 1];

  logics[index] = logicToReplace;
  logics[index - 1] = logicToMove;

  if (logics[index].status !== 'new') {
    logics[index].status = 'update';
  }

  if (logics[index - 1].status !== 'new') {
    logics[index - 1].status = 'update';
  }

  setLogics([...logics]);
};

const _onClickDown = (useLogics: UseLogics) => (index: number) => () => {
  const [logics, setLogics] = useLogics;

  const logicToMove = logics[index];
  const logicToReplace = logics[index + 1];

  logics[index] = logicToReplace;
  logics[index + 1] = logicToMove;

  if (logics[index].status !== 'new') {
    logics[index].status = 'update';
  }

  if (logics[index + 1].status !== 'new') {
    logics[index + 1].status = 'update';
  }

  setLogics([...logics]);
};

export default () => {
  const [isLoading, setIsLoading] = useState(true);
  const [isError, setIsError] = useState(false);
  const useLogics = useState<LogicForm[]>([]);
  const [logics, setLogics] = useLogics;
  const useToDelete = useState<number[]>([]);
  const [nextTasks, setNextTasks] = useState<NextTask[]>([]);
  const [agbID, setAgbID] = useState<number>();


  const onSave = () => {
    // Filtert leere Reihen und Subreihen aus
    const cleanedLogics = logics
      .map((logic) => {
        // Entfernt leere Subreihen
        const filteredSubConditions = (logic.conditions || []).filter(
          (subCondition) => subCondition.condition !== '' || subCondition.value !== ''
        );
  
        return {
          ...logic,
          conditions: filteredSubConditions,
        };
      })
      .filter(
        (logic) =>
          logic.condition !== '' || logic.next_task_id !== '' || logic.conditions.length > 0
      );
  
    // Überprüfen, ob es unvollständige Reihen oder Subreihen gibt
    const incompleteLogic = cleanedLogics.some(
      (logic) =>
        (logic.condition === '' && logic.next_task_id !== '') ||
        (logic.condition !== '' && logic.next_task_id === '') ||
        logic.conditions.some(
          (subCondition) =>
            (subCondition.condition === '' && subCondition.value !== '') ||
            (subCondition.condition !== '' && subCondition.value === '')
        )
    );
  
    if (incompleteLogic) {
      alert("Bitte füllen Sie alle Felder aus, bevor Sie speichern.");
      return false; // Speichern wird abgebrochen
    }
  
    const logicPayload = cleanedLogics.map((logic, index) => ({
      id: logic.id,
      order: index,
      condition: logic.condition,
      value: logic.value,
      nextTaskID: logic.next_task_id,
      subConditions: logic.conditions.map((subCondition) => ({
        condition: subCondition.condition,
        value: subCondition.value,
      })),
    }));
  
    const payload = { logics: logicPayload, delete: useToDelete[0] };
    axios.post(`/agbs/${agbID}/logics`, payload);
  
    return true; // Speichern erfolgreich
  };
  

  useEffect(() => {
    const init = async () => {
      setIsError(false);
      setIsLoading(true);
      let _agbID = document.getElementById('current-id')?.dataset?.currentId;
      const agbIsNotANumber = isNaN(parseInt(_agbID));
      if (agbIsNotANumber) {
        setIsError(true);
        setIsLoading(false);
        return;
      }
      let agbID = parseInt(_agbID);
      setAgbID(agbID);
      const [responseDyns, responseLogics] = await Promise.all([
        getDyns(agbID),
        getLogics(agbID)
      ]);
      if (responseDyns === false || responseLogics === false) {
        setIsError(true);
        setIsLoading(false);
        return;
      }

      const _nextTasks: NextTask[] = [];
      for (let rDyns of responseDyns) {
        _nextTasks.push({
          value: rDyns.agb_id,
          name: rDyns.agb_name
        });
      }

      const _logics: LogicForm[] = [];
      for (let rLogic of responseLogics) {
        let nextTaskID: LogicForm['next_task_id'] = '';
        for (let nextTask of _nextTasks) {
          if (nextTask.value !== rLogic.next_task_id) {
            continue;
          }
          nextTaskID = nextTask.value;
        }
      
        _logics.push({
          id: rLogic.id,
          order: rLogic.order,
          condition: rLogic.condition,
          value: rLogic.value,
          next_task_id: nextTaskID,
          status: 'original',
          conditions: rLogic.sub_conditions ? rLogic.sub_conditions.map((subCondition) => ({
            condition: subCondition.condition,
            value: subCondition.value,
            id: subCondition.id,
          })) : [] // `sub_conditions` aus dem Backend zuweisen
        });
      }
      _logics.push(createNewField(_logics.length));

      setNextTasks(_nextTasks);
      setLogics(_logics);
      setIsError(false);
      setIsLoading(false);
    };

    init();
  }, [setLogics]);

  const onChange = _onChange(useLogics);
  const onDelete = _onDelete(useLogics, useToDelete);
  const onClickUp = _onClickUp(useLogics);
  const onClickDown = _onClickDown(useLogics);

  return [
    { isLoading, isError, logics, nextTasks, agbID },
    { onChange, onDelete, onClickUp, onClickDown, onSave, setLogics }
  ];
};