import React, { useEffect, useRef, useState } from "react";
import moment from "moment";
import { cloneDeep } from "lodash";
import { Button, Space, DatePicker } from "antd";

import * as commonUtils from "@/utils/utils";
import * as commonFunc from "@/components/Common/commonFunc";
import * as commonBusiness from "@/components/Common/commonBusiness";
import useCommonBase from "@/components/Common/CommonHooks/useCommonBase";
import StaticEditTable from "@/components/Common/CommonTable";
import CommonViewTable from "@/components/Common/CommonViewTable";
import RunningStatus from "@/mes/common/RunningStatus";
import ReportInfo from "@/mes/productionExec/noticeModal/reportInfoButton";

import styles from "./index.less";

// salve0 -> 报工任务 slave1 -> 行车状态 slave2 -> 提报信息
const tableList = ["slave0", "slave1", "slave2"];

const useAbnormalEventReportingEvent = props => {
  const { formData = [] } = props;

  // 初始化事件
  useEffect(
    async () => {
      if (commonUtils.isNotEmptyArr(formData)) {
        let addState = {};
        const colunmData = handleGetColumnData(tableList, true);
        const result = await handleGetData(tableList, true);
        addState = {
          ...addState,
          ...colunmData,
          ...result,
          bFinish: 1
        };
        props.onSaveState(addState);
      }
    },
    [formData.length]
  );

  // 获取表头数据
  const handleGetColumnData = (tableList = [], isWait) => {
    let addState = {};
    for (let i = 0; i < tableList.length; i++) {
      const tableName = tableList[i];
      const config = formData.find(item => item.sGrd === tableName);
      if (!config) continue;
      const column = commonFunc.getHeaderConfig(config);
      addState = {
        ...addState,
        [`${tableName}Column`]: column,
        [`${tableName}Config`]: config
      };
    }
    if (isWait) {
      return addState;
    } else {
      props.onSaveState(addState);
    }
  };

  // 获取数据集
  const handleGetData = async (tableList = [], isWait) => {
    let addState = {};
    for (let i = 0; i < tableList.length; i++) {
      const tableName = tableList[i];
      const config = formData.find(item => item.sGrd === tableName);
      if (!config) continue;
      const conditonValues = props.onGetSqlConditionValues(config);
      // 行车记录新增时间、白夜班条件
      if (tableName === "slave0") {
        // 判断当前时间是否小于上午8点，如果是，则默认为昨天
        const now = moment();
        const today8AM = moment()
          .hour(8)
          .minute(0)
          .second(0)
          .millisecond(0);
        const isBefore8AM = now.isSameOrBefore(today8AM);
        const {
          runningTime = isBefore8AM
            ? now.subtract(1, "days").format("YYYY-MM-DD")
            : now.format("YYYY-MM-DD")
        } = props;
        conditonValues.tCreateTime = runningTime;
      }

      const iSort =
        props.app?.userinfo?.sWorkshopId === "20240511102738235320239993832437"
          ? 1
          : 0;
      const result =
        (await props.onGetDataSet({
          name: tableName,
          configData: config,
          condition: {
            sSqlCondition: { ...conditonValues, iSort }
          },
          isWait: true
        })) || {};
      props.setTempRef(result);

      if (tableName?.includes("master")) {
        const masterData = result[`${tableName}Data`];
        result[`${tableName}Data`] = masterData?.[0] || {};
      } else {
        // 如果选中的数据不在返回的数据中，则清空选中数据
        const { [`${tableName}Data`]: tableData = [] } = result;
        const { [`${tableName}SelectedRowKeys`]: selectedRowKeys = [] } = props;
        if (selectedRowKeys.length) {
          const selectedRowKeysNew = selectedRowKeys.filter(item =>
            tableData.some(rowData =>
              [rowData.sId, rowData.sSlaveId].includes(item)
            )
          );
          result[`${tableName}SelectedRowKeys`] = selectedRowKeysNew;
        }
      }

      // 如果配置了默认选中第一行,则默认选中第一行,刷新数据集时配置NotFirstlineSelected则不刷新
      let bNotFirstlineSelected =
        tableList.findIndex(
          item => item === `${tableName}NotFirstlineSelected`
        ) > -1;

      if (!bNotFirstlineSelected) {
        // 如果配置了默认选中第一行,则默认选中第一行
        let bFirstlineSelected = config.gdsconfigformslave.find(
          item => item.sControlName === "bFirstlineSelected" && item.bVisible
        );
        // 配置刷新数据时，配置 数据集名称+FirstlineSelected，默认选中首行数据。
        if (!bFirstlineSelected) {
          bFirstlineSelected =
            tableList.findIndex(
              item => item === `${tableName}FirstlineSelected`
            ) > -1;
        }
        if (bFirstlineSelected) {
          if (commonUtils.isNotEmptyObject(result[`${tableName}Data`])) {
            result[`${tableName}SelectedRowKeys`] = [
              result[`${tableName}Data`][0].sId
            ];
            result.triggerClickTableList = result.triggerClickTableList || [];
            result.triggerClickTableList.push(tableName);
          }
        }
      }

      addState = { ...addState, ...result };
    }
    props.setTempRef({}, true);
    if (isWait) {
      return addState;
    } else {
      props.onSaveState(addState);
    }
  };

  const handleBtnClick = config => {
    const { sButtonParam, sInstruct } = config;

    // 调用指令集
    if (sInstruct) {
      props.onExecInstructSet({
        ...props,
        btnConfig: config,
        callback: () => {
          const slave2RowData = {
            handleType: "add",
            sId: commonUtils.createSid()
          };
          props.onSaveState({
            slave2Data: [slave2RowData]
          });
        }
      });
      return;
    }

    // 调用存储过程
    if (sButtonParam) {
      handleProcedureCall(config);
    }
  };

  // 调用存储过程
  const handleProcedureCall = config => {
    props.onProcedureCall({
      btnConfig: config,
      onSuccess: () => {
        props.onRefresh && props.onRefresh();
      },
      onConfirm: () => {},
      onError: () => {}
    });
  };

  // 刷新指定表格
  const { refreshTableList = [] } = props;
  useEffect(
    async () => {
      if (!refreshTableList.length) return;

      if (refreshTableList.includes("slave")) {
        window.refreshTableList = ["slave"];
      }

      const refreshTableListNew = refreshTableList.filter(
        item => item !== "slave"
      );

      if (!refreshTableListNew.length) {
        props.onSaveState({ refreshTableList: [] });
        return;
      }

      let addState = {
        refreshTableList: [],
        ...(await handleGetData(refreshTableListNew, true))
      };

      if (props.runningStatusConditionFlag) {
        addState = {
          ...addState,
          runningStatusConditionFlag: undefined,
          slave0SelectedRowKeys: [],
          slave2Data: []
        };
      }

      props.onSaveState(addState, nextProps => {
        if (window.rowclickAfterFunc) {
          window.rowclickAfterFunc(nextProps);
          window.rowclickAfterFunc = null;
        }
      });
    },
    [refreshTableList.length]
  );

  return {
    ...props,
    onBtnClick: handleBtnClick
  };
};

const AbnormalEventReporting = baseProps => {
  const props = useAbnormalEventReportingEvent(useCommonBase(baseProps));
  return (
    <div className={styles.abnormalEventReporting}>
      <LeftPartComponent {...props} />
      <RightPartComponent {...props} />
    </div>
  );
};

const LeftPartComponent = props => {
  const tableName = "slave0";
  const baseProps = commonBusiness.getTableTypes(tableName, props);
  if (tableName === "slave0") {
    baseProps.allowClear = false;
  }
  const { data = [] } = baseProps;
  useEffect(
    () => {
      if (!data.length) return;
      // 让第一条选中
      props.onTableSelectRowChange(tableName, [data[0].sId]);
      props.onSaveState({
        [`${tableName}SelectedRowKeys`]: [data[0].sAbnormalEventId]
      });
    },
    [!!data.length]
  );

  const { [`${tableName}SelectedRowKeys`]: selectedRowKeys = [] } = props;
  const [selectedRowKey = ""] = selectedRowKeys;
  useEffect(
    () => {
      if (!selectedRowKey) return;
      props.onSaveState({
        refreshTableList: ["slave2"]
      });
    },
    [selectedRowKey]
  );

  const tableProps = {
    ...baseProps,
    fixedHeight: "calc(100% - 50px)"
  };

  return (
    <div className={styles.leftPart}>
      <RunningStatusConditionComponent {...props} />
      <StaticEditTable {...tableProps} />
    </div>
  );
};

const RightPartComponent = props => {
  const [reportInfoVisible, setReportInfoVisible] = useState(false);
  const reportRef = useRef(null);

  const handleReportInfo = (config = null) => {
    reportRef.current = config;
    setReportInfoVisible(!reportInfoVisible);
  };

  const tableName = "slave2";
  const { config: configOld, data = [] } = commonBusiness.getTableTypes(
    tableName,
    props
  );
  const config = props.onMergeTableConfig(configOld);
  const viewConfigsOld = config?.gdsconfigformslave?.filter(
    item =>
      item.sName &&
      item.bControl &&
      item.sControlName.indexOf("Btn") === -1 &&
      item.sControlName.indexOf("_") === -1
  );

  const viewConfigs = cloneDeep(viewConfigsOld);
  const iIndex =
    viewConfigs?.findIndex(item => item.sName === "bRepairRequest") || -1;
  if (iIndex !== -1 && !data[0]?.sAbnormalStatusName?.startsWith("W")) {
    viewConfigs[iIndex].iTag = 1;
  }

  const slave0SelectedRowKeys = props.slave0SelectedRowKeys || [];
  const viewRow = slave0SelectedRowKeys.length
    ? props.slave0Data?.filter(item =>
        slave0SelectedRowKeys.includes(item.sId)
      )[0]
    : {};

  const viewProps = {
    ...props,
    viewConfigs,
    tableConfig: config,
    iColValueView: 24,
    viewRow: data[0],
    tableName,
    enabled: false,
    handleReportInfo
  };

  if (commonUtils.isEmptyObject(viewRow) || viewRow.bUnChanged) {
    viewProps.enabledCostom = false;
  }

  const btnConfig = config?.gdsconfigformslave?.find(
    item => item.sControlName === "BtnRight.confim"
  );

  const btnProps = {
    type: "primary",
    size: "large",
    // disabled: !(viewRow?.bSaveAbnormal == 0),
    onClick: props.onBtnClick.bind(this, btnConfig)
  };

  const runningStatusProps = {
    ...props,
    bNotModal: true,
    tableName: "slave1",
    viewRow,
    onChange: (rowData, nextProps) => {
      // 如果配置了指令集，调用指令集
      const btnConfig = props[
        `${runningStatusProps.tableName}Config`
      ]?.gdsconfigformslave?.find(item => item.sControlName === "clickOpr");

      if (btnConfig) {
        props.onExecInstructSet({
          btnConfig,
          tableLineParams: {
            name: runningStatusProps.tableName,
            record: rowData
          },
          nextProps
        });
      }
      // const iIndex = props.slave0Data.findIndex(
      //   item => item.sId === slave0SelectedRowKeys[0]
      // );
      // const newData = [...props.slave0Data];
      // newData[iIndex] = {
      //   ...newData[iIndex],
      //   sAbClassifyName: rowData.sClassifyName1,
      //   sAbClassifycode: rowData.sClassifyName,
      //   sAbsStatusName: rowData.sStatusName
      // };
      // props.onSaveState(
      //   {
      //     slave0Data: newData
      //   },
      //   () => {
      //     // 如果配置了指令集，调用指令集
      //     const btnConfig = props[
      //       `${runningStatusProps.tableName}Config`
      //     ]?.gdsconfigformslave?.find(item => item.sControlName === "clickOpr");

      //     if (btnConfig) {
      //       props.onExecInstructSet({
      //         btnConfig,
      //         tableLineParams: {
      //           name: runningStatusProps.tableName,
      //           record: rowData
      //         }
      //       });
      //     }
      //   }
      // );
    }
  };

  return (
    <div className={styles.rightPart}>
      <div className={styles.runningStatus}>
        <RunningStatus {...runningStatusProps} />
      </div>
      <div className={styles.runningForm}>
        <CommonViewTable {...viewProps} />
        <ReportInfo
          reportInfoVisible={reportInfoVisible}
          handleReportInfo={handleReportInfo}
          {...props}
          reportRef={reportRef.current || {}}
          hasShowInfo={viewProps.viewRow}
        />
      </div>
      <div className={styles.runningBtn}>
        <Button {...btnProps}>提报</Button>
      </div>
    </div>
  );
};

// （定制功能）行车记录 条件
const RunningStatusConditionComponent = props => {
  const { runningTime } = props;
  // 判断当前时间是否小于上午8点，如果是，则默认为昨天
  const now = moment();
  const today8AM = moment()
    .hour(8)
    .minute(0)
    .second(0)
    .millisecond(0);
  const isBefore8AM = now.isSameOrBefore(today8AM);

  const [dateValue, setDateValue] = useState(
    runningTime
      ? moment(runningTime)
      : isBefore8AM
        ? now.subtract(1, "days")
        : now
  );

  const flag = useRef(false);
  useEffect(
    () => {
      if (flag.current) {
        flag.current = false;
        props.onSaveState({
          runningTime: dateValue.format("YYYY-MM-DD"),
          refreshTableList: ["slave0"],
          runningStatusConditionFlag: true // 行车记录修改时间标记
        });
      }
    },
    [dateValue]
  );

  return (
    <div className="tabTitle">
      <div className={styles.runningStatusCondition}>
        <Space size={15}>
          <DatePicker
            value={dateValue}
            format="YYYY-MM-DD"
            allowClear={false}
            onChange={mDate => {
              flag.current = true;
              setDateValue(mDate);
            }}
            size="large"
          />
        </Space>
      </div>
    </div>
  );
};

export default AbnormalEventReporting;