import {
  ComponentInfo,
  ComponentTypeEnum,
  CreateComponentQuery,
  IVector3,
  ComponentDetailInfo,
  StateTypeEnum,
} from '@easytwin/core';
import { request } from '@/utils';
import { BatchModelPrams } from '@/pages/ProjectEditor/components/OfficialModelPopup';
import apis from '../../constants/api.swagger-constants';
import { FileApi } from '../File';
import { initStateData } from '../State';
import { getDetail, getTree } from './api';

export async function createByModel(query: {
  sceneId: string;
  modelFile: File;
  parentObjId?: string;
}): Promise<ComponentInfo | null> {
  try {
    const { parentObjId, sceneId, modelFile } = query;
    const modelUrl = await FileApi.upload(
      `/model/${modelFile.lastModified}_${modelFile.name}`,
      modelFile,
    );

    const defaultModelState = {
      type: StateTypeEnum.MODEL,
      name: '状态',
      config: initStateData[StateTypeEnum.MODEL],
    };

    // 后端字段限制 32 个字符
    const name = modelFile.name.split('.')[0].slice(0, 32);

    const data = await createComponent({
      name,
      sceneId,
      type: ComponentTypeEnum.MODEL,
      // parentObjId,
      commonConfig: {
        isGroup: false,
        fileUrl: modelUrl,
      },
      stateConfig: [defaultModelState],
    });

    const tree = await getTree({ sceneId });
    const result = tree.find((item) => item.id === data.objId);
    if (result) return result;
    return null;
  } catch (err) {
    console.error('createComponenterByLocalModel:', err);
    return Promise.reject(new Error('创建空间对象失败!'));
  }
}

export async function createLight({
  type,
  sceneId,
  name,
  parentObjId,
}: {
  sceneId: string;
  parentObjId?: string;
  type: ComponentTypeEnum;
  name: string;
}) {
  try {
    const defaultModelState = {
      type,
      name: '状态',
      config: initStateData[type],
    };

    const data = await createComponent({
      name,
      sceneId,
      type: ComponentTypeEnum[type],
      parentObjId,
      stateConfig: [defaultModelState],
    });

    const tree = await getTree({ sceneId });
    const result = tree.find((item) => item.id === data.objId);
    if (result) return result;
    return null;
  } catch (error) {
    console.error('createLight:', error);
    return Promise.reject(new Error('创建空间对象失败!'));
  }
}

export async function createComponent(params: {
  name: string;
  type: ComponentTypeEnum;
  sceneId: string;
  commonConfig?: Record<string, any>;
  parentObjId?: string;
  stateConfig?: Record<string, any>[];
}) {
  const { name, sceneId, type, parentObjId, commonConfig = {}, stateConfig = [] } = params;

  const result = await request(apis.scenesObjsPost, {
    params: {
      sceneId,
    },
    body: {
      name,
      type,
      commonConfig,
      stateConfig,
      viewpointConfig: [],
      animationConfig: [],
      parentObjId,
    },
  });

  return result;
}

export async function createByModelUrl(query: {
  sceneId: string;
  modelUrl: string;
  parentObjId?: string;
}): Promise<ComponentDetailInfo | null> {
  try {
    const { parentObjId, sceneId, modelUrl } = query;
    const defaultModelState = {
      type: StateTypeEnum.MODEL,
      name: '状态',
      config: initStateData[StateTypeEnum.MODEL],
    };

    const data = await createComponent({
      name: modelUrl.slice(-32),
      sceneId,
      type: ComponentTypeEnum.MODEL,
      // parentObjId,
      commonConfig: {
        fileUrl: modelUrl,
      },
      stateConfig: [defaultModelState],
    });

    const result = await getDetail({ id: data.objId, sceneId });
    return result;
  } catch (err) {
    console.error('createComponenterByLocalModel:', err);
    return Promise.reject(new Error('创建空间对象失败!'));
  }
}

export async function createByBatchModelGroup(query: {
  sceneId: string;
  config: BatchModelPrams;
  parentObjId?: string;
}): Promise<ComponentDetailInfo | null> {
  try {
    const {
      parentObjId,
      sceneId,
      config: { modelUrl, mode, count },
    } = query;
    const defaultModelState = {
      type: StateTypeEnum.MODEL,
      name: '状态',
      config: initStateData[StateTypeEnum.MODEL],
    };
    const config = mode === 'gapless' ? {} : { count };
    const data = await createComponent({
      name: modelUrl.slice(-32),
      sceneId,
      type: ComponentTypeEnum.BATCH,
      // parentObjId,
      commonConfig: {
        fileUrl: modelUrl,
        isGroup: true,
        config: {
          ...config,
          mode,
          close: false,
          scaleTotal: {
            locked: true,
            x: 1,
            y: 1,
            z: 1,
          },
          scaleSingle: {
            locked: true,
            x: 1,
            y: 1,
            z: 1,
          },
        },
      },
      stateConfig: [defaultModelState],
    });
    const result = await getDetail({ id: data.objId, sceneId });
    return result;
  } catch (err) {
    console.error('createComponenterByLocalModel:', err);
    return Promise.reject(new Error('创建空间对象失败!'));
  }
}

export async function createByBatchModel(query: {
  sceneId: string;
  config: BatchModelPrams & { positions: IVector3[] };
  parentObjId?: string;
}): Promise<ComponentDetailInfo | null> {
  try {
    const {
      parentObjId,
      sceneId,
      config: { modelUrl, mode, count, positions },
    } = query;
    const defaultModelState = {
      type: StateTypeEnum.LINE,
      name: '状态',
      config: initStateData[StateTypeEnum.LINE],
    };
    const data = await createComponent({
      name: modelUrl.slice(-32),
      sceneId,
      type: ComponentTypeEnum.LINE,
      parentObjId,
      commonConfig: {
        fileUrl: modelUrl,
        config: {
          line: positions,
          mode,
          count,
        },
      },
      stateConfig: [defaultModelState],
    });
    const result = await getDetail({ id: data.objId, sceneId });
    return result;
  } catch (err) {
    console.error('createComponenterByLocalModel:', err);
    return Promise.reject(new Error('创建空间对象失败!'));
  }
}