import { Ref, nextTick, toRaw, unref } from 'vue';
import { FlipFlopConditionType, FlipFlopFormRecordType, FlipFlopItemType } from './types';
import { DefineComponentsBasicExpose } from '/#/utils';
import { FormFieldEnum } from './config';
import {
  DeviceTriggerTypeEum,
  FlipFlopTypeEnum,
  StringOperationEnum,
  TriggerValueTypeEnum,
} from '/@/enums/linkedgeEnum';
import { createNewFlipFlopItem } from '.';
import { ConditionItemType } from '../ConditionFilter/type';

export function useFlipFlopData(
  flipFlopListRef: Ref<FlipFlopItemType[]>
): DefineComponentsBasicExpose<FlipFlopConditionType[]> {
  const getEventTriggerCOndition = (
    basicRecord: FlipFlopFormRecordType,
    _flipFlopItem: FlipFlopItemType
  ): ConditionItemType[] => {
    const { deviceEventTriggerKey } = basicRecord;
    return [
      {
        key: {
          type: DeviceTriggerTypeEum.DEVICE_EVENT,
          key: deviceEventTriggerKey,
        },
        valueType: TriggerValueTypeEnum.STRING,
        predicate: {
          type: TriggerValueTypeEnum.STRING,
          operation: StringOperationEnum.EQUAL,
          value: {
            defaultValue: deviceEventTriggerKey,
          },
        },
      },
    ];
  };

  const getCondition = (basicRecord: FlipFlopFormRecordType, flipFlopItem: FlipFlopItemType) => {
    const { conditionType } = basicRecord;
    return conditionType === DeviceTriggerTypeEum.TIME_SERIES
      ? flipFlopItem.conditionRef?.getFieldsValue() || []
      : getEventTriggerCOndition(basicRecord, flipFlopItem);
  };

  const crateFlipFlopCondition = (flipFlopItem: FlipFlopItemType): FlipFlopConditionType => {
    const basicRecord = flipFlopItem.ref?.getFieldsValue() as FlipFlopFormRecordType;
    const {
      deviceProfileId,
      deviceType,
      entityId,
      entityType,
      triggerType,
      flipFlopType,
      triggerDurationUnit,
      triggerRepeatCount,
      triggerDurationValue,
    } = basicRecord;

    const condition = getCondition(basicRecord, flipFlopItem);

    return {
      deviceProfileId,
      deviceType,
      entityId,
      entityType,
      triggerType,
      triggerCondition: {
        condition: {
          condition,
          spec: {
            type: flipFlopType,
            ...(flipFlopType !== FlipFlopTypeEnum.SIMPLE
              ? {
                  unit: triggerDurationUnit,
                  predicate: {
                    defaultValue:
                      flipFlopType === FlipFlopTypeEnum.DURATION
                        ? triggerDurationValue
                        : triggerRepeatCount,
                  },
                }
              : {}),
          },
        },
        schedule: toRaw(unref(flipFlopItem.schedule)),
      },
    };
  };

  const getFieldsValue = () => {
    return unref(flipFlopListRef).map((flipFlopItem) => crateFlipFlopCondition(flipFlopItem));
  };

  const setFieldsValue = (flipFlopData: FlipFlopConditionType[]) => {
    flipFlopListRef.value = Array.from({ length: flipFlopData.length }, () =>
      createNewFlipFlopItem()
    );

    nextTick(() => {
      unref(flipFlopListRef).forEach((item, index) => {
        const data = flipFlopData[index];
        const condition = data.triggerCondition.condition;
        const [firstItem] = condition.condition;
        const { key, valueType } = firstItem;
        const { type, unit, predicate } = condition.spec;
        const { defaultValue } = predicate || {};

        const record = {
          ...data,
          [FormFieldEnum.FLIP_FLOP_TYPE]: type,
          [FormFieldEnum.CONDITION_KEY]: key.key,
          [FormFieldEnum.CONDITION_TYPE]: key.type,
          [FormFieldEnum.CONDITION_VALUE_TYPE]: valueType,
          [FormFieldEnum.TRIGGER_DURATION_UNIT]: unit,
          [FormFieldEnum.TRIGGER_DURATION_VALUE]:
            type === FlipFlopTypeEnum.DURATION ? defaultValue : null,
          [FormFieldEnum.TRIGGER_REPEAT_COUNT]:
            type === FlipFlopTypeEnum.REPEATING ? defaultValue : null,
        };

        if (key.type === DeviceTriggerTypeEum.DEVICE_EVENT) {
          Object.assign(record, {
            [FormFieldEnum.DEVICE_EVENT_TRIGGER_KEY]: key.key,
            [FormFieldEnum.CONDITION_KEY]: null,
          });
        }

        item.ref?.setFieldsValue(record);

        const {
          daysOfWeek,
          startsOn = 0,
          endsOn = 0,
          timezone,
          type: scheduleType,
          items,
        } = data.triggerCondition.schedule;
        item.schedule = {
          type: scheduleType,
          timezone,
          daysOfWeek,
          startsOn,
          endsOn,
          items,
        };

        nextTick(() => {
          item.conditionRef?.setFieldsValue(condition.condition);
        });
      });
    });
  };

  const validate = async () => {
    for (const flipFlopItem of unref(flipFlopListRef)) {
      await flipFlopItem.ref?.validate();
      await flipFlopItem.conditionRef?.validate?.();
    }
  };

  const resetFieldsValue = (defaultNull?: boolean) => {
    flipFlopListRef.value = defaultNull ? [] : [createNewFlipFlopItem()];
  };

  return {
    getFieldsValue,
    setFieldsValue,
    validate,
    resetFieldsValue,
  };
}