import { Ref, unref, nextTick, toRaw } from 'vue';
import { DefineComponentsBasicExpose } from '/#/utils';
import {
  DoContextAlarmType,
  DoContextType,
  ExecutionActionDataItemType,
  ExecutionActionFormItemRecordType,
  ExecutionActionListRefItemType,
} from './type';
import { ExecutionActionEnum } from '/@/enums/linkedgeEnum';
import { CommandTypeEnum } from '/@/enums/deviceEnum';
import { useJsonParse } from '/@/hooks/business/useJsonParse';
import { createNewExecutionActionItem } from '.';
import { FormFieldsEnum } from './config';
import { isObject, isString } from '/@/utils/is';
import { TransportTypeEnum } from '/@/enums/deviceEnum';

export function useExecutionActionData(
  executionActionListRef: Ref<ExecutionActionListRefItemType[]>,
  hasAlarmNotify: Ref<boolean>
): DefineComponentsBasicExpose<ExecutionActionDataItemType[]> {
  const getExecutionActionItemData = (executionActionItem: ExecutionActionListRefItemType) => {
    const { ref, alarmClearRuleElRef, thingsModelFormRefl } = executionActionItem;
    const {
      callType,
      commandType,
      deviceType,
      deviceProfileId,
      entityType,
      entityId,
      outTarget,
      transportType,
      alarmLevel,
      callServiceIdentifier,
      serviceId,
      tcpCustomCommand,
      customCommand,
      alarmProfileId,
    } = (ref?.getFieldsValue?.() || {}) as Required<ExecutionActionFormItemRecordType>;

    const thingsModelFormRecord = thingsModelFormRefl?.getFieldsValue?.();

    const clearRule = alarmClearRuleElRef?.getFieldsValue();

    const record: ExecutionActionDataItemType = {
      callType,
      commandType,
      alarmProfileId,
      deviceType,
      deviceProfileId,
      entityType,
      deviceId: entityId,
      outTarget,
      thingsModelId: serviceId,
      doContext: {},
    };

    if (outTarget === ExecutionActionEnum.DEVICE_OUT) {
      record.doContext = {
        method: 'methodThingskit',
        additionalInfo: { cmdType: commandType },
        params:
          commandType === CommandTypeEnum.CUSTOM
            ? transportType === TransportTypeEnum.TCP
              ? tcpCustomCommand
              : useJsonParse(customCommand).value
            : {
                [callServiceIdentifier]: thingsModelFormRecord,
              },
      };
    } else {
      record.doContext = {
        alarmLevel,
        clearRule: clearRule || [],
      };
    }

    return record;
  };

  const getFieldsValue = () => {
    const dataList: ExecutionActionDataItemType[] = [];
    for (const executionActionItem of unref(executionActionListRef)) {
      dataList.push(getExecutionActionItemData(executionActionItem));
    }

    return dataList;
  };

  const setFieldsValue = (executionActionData: ExecutionActionDataItemType[]) => {
    executionActionListRef.value = Array.from({ length: executionActionData.length }, () =>
      createNewExecutionActionItem()
    );

    nextTick(() => {
      unref(executionActionListRef).forEach((executionActionItem, index) => {
        const result = executionActionData[index];

        const { doContext, outTarget, commandType } = result;

        const { thingsModelId, deviceId } = result;

        const record = {
          ...result,
          [FormFieldsEnum.SERVICE_ID]: thingsModelId,
          [FormFieldsEnum.ENTITY_ID]: deviceId,
        };

        if (outTarget === ExecutionActionEnum.MSG_NOTIFY) {
          const { alarmLevel, clearRule } = doContext as DoContextAlarmType;
          Object.assign(record, {
            [FormFieldsEnum.ALARM_LEVEL]: alarmLevel,
            [FormFieldsEnum.ENABLE_CLEAR_RULE]: !!(clearRule && clearRule.length),
          });
          hasAlarmNotify.value = true;
        }

        if (outTarget == ExecutionActionEnum.DEVICE_OUT && (doContext as DoContextType)?.params) {
          const { params } = doContext as DoContextType;
          Object.assign(record, {
            [isString(params) ? FormFieldsEnum.TCP_CUSTOM_COMMAND : FormFieldsEnum.CUSTOM_COMMAND]:
              params,
          });
        }

        if (
          outTarget === ExecutionActionEnum.DEVICE_OUT &&
          commandType === CommandTypeEnum.SERVICE
        ) {
          const { params } = doContext as DoContextType;
          if (isObject(params)) {
            const [identifier] = Object.keys(params);
            const result = params[identifier];
            Object.assign(record, { [FormFieldsEnum.SERVICE_COMMAND]: toRaw(result || {}) });
            executionActionItem.thingsModelFormRefl?.setFieldsValue(result || {});
          }
        }

        executionActionItem.ref?.setFieldsValue(record);

        if (
          outTarget === ExecutionActionEnum.MSG_NOTIFY &&
          (doContext as DoContextAlarmType).clearRule &&
          (doContext as DoContextAlarmType).clearRule.length
        ) {
          nextTick(() => {
            executionActionItem.alarmClearRuleElRef?.setFieldsValue(
              (result.doContext as DoContextAlarmType).clearRule
            );
          });
        }
      });
    });
  };

  const validate = async () => {
    for (const executionActionItem of unref(executionActionListRef)) {
      const { ref, alarmClearRuleElRef, thingsModelFormRefl } = executionActionItem;
      await ref?.validate?.();
      await alarmClearRuleElRef?.validate?.();
      await thingsModelFormRefl?.validate?.();
    }
  };

  const resetFieldsValue = () => {
    executionActionListRef.value = [createNewExecutionActionItem()];
    hasAlarmNotify.value = false;
  };

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