import {
  MoveGroupBaseInfos,
  RemoveBaseInfos,
  RecycleBaseInfos,
  ProjectInfo,
  ProjectDetailInfo,
  GetProjecPageListQuery,
  GetProjecRecyclePageListQuery,
  CreateProjectQuery,
  CreateProjectData,
  UpdateProjectQuery,
  CopyProjectQuery,
  ExportProjectQuery,
  StateInfo,
  ViewpointInfo,
  SceneCommonConfig,
  StateTypeEnum,
  ProjectStateConfig,
  SceneStateConfig,
  SceneViewpointConfig,
  ImportProjectQuery,
  ExportProjectData,
  ImportProjectData,
  CopyProjectData,
} from '@easytwin/core';


import { request } from '@/utils';
import apis from '@/constants/api.swagger-constants';
import { initStateData } from '@/server';
import { SceneApi } from '..';
import { initSceneData } from '../../constants/scene';

/**
 * 获取项目列表
 * @param { GetProjecPageListQuery } query
 * @returns { Promise<ProjectInfo[]> }
 */
export async function getList(query: GetProjecPageListQuery): Promise<ProjectInfo[]> {
  try {
    return await request(apis.projectsGet, { query });
  } catch (err) {
    console.error('getProjectList:', err);
    return Promise.reject('获取项目列表失败!');
  }
}

/**
 * TODO: 获取项目模版列表
 * @returns { Promise<ProjectInfo[]> }
 */
export async function getTemplateList(): Promise<ProjectInfo[]> {
  try {
    return [];
  } catch (err) {
    console.error('getProjectTemplateList:', err);
    return Promise.reject('获取项目模版列表失败!');
  }
}

/**
 * 获取项目列表
 * @param { GetProjecRecyclePageListQuery } query
 * @returns { Promise<ProjectInfo[]> }
 */
export async function getRecycleList(query: GetProjecRecyclePageListQuery): Promise<ProjectInfo[]> {
  try {
    return await request(apis.projectsGet, { query });
  } catch (err) {
    console.error('getProjectRecycleList:', err);
    return Promise.reject(new Error('获取项目回收列表失败!'));
  }
}

/**
 * 通过 iD 获取项目
 * @param { string } id
 * @returns { Promise<ProjectDetailInfo | void> }
 */
export async function getDetail(id: string): Promise<ProjectDetailInfo | void> {
  try {
    const info: ProjectInfo = await request(apis.projectGet, { params: { id } });

    const scene = await request(apis.projectsScenesGet, { params: { projectId: id } });

    if (!(info || scene)) return;

    const { commonConfig, stateConfig, viewpointConfig: viewpoints } = scene;

    return {
      ...info,
      scenes: [
        {
          ...scene,
          commonConfig: commonConfig as SceneCommonConfig,
          viewpointConfig: viewpoints as SceneViewpointConfig[],
          stateConfig: stateConfig as SceneStateConfig[],
        },
      ],
    };
  } catch (err) {
    console.error('getProjectById:', err);
    return Promise.reject('获取项目信息失败!');
  }
}

/**
 * 创建项目或项目组
 * @param { CreateProjectQuery } query
 * @returns { Promise<ProjectInfo> }
 */
export async function create(
  query: CreateProjectQuery,
  isCreateDefaultState: boolean = true,
): Promise<CreateProjectData | void> {
  try {
    const newData: CreateProjectData = await request(apis.projectsPost, {
      body: { groupId: query.groupId },
    });

    if (!isCreateDefaultState) return;

    const scene = await request(apis.projectsScenesGet, {
      params: { projectId: newData.projectId },
    });

    // 由于初始化项目中的commonConfig为空对象，所以需要手动更新场景配置 commonConfig，包括里面的near, far等场景配置，不然新创建的场景里面啥也没有
    await SceneApi.update({
      sceneId: scene.id,
      projectId: newData.projectId,
      commonConfig: { config: initSceneData },
    });

    await SceneApi.createState({
      sceneId: scene.id,
      name: '状态',
      config: initStateData[StateTypeEnum.PROJECT] as ProjectStateConfig,
    });

    return newData;
  } catch (err) {
    console.error('createProject:', err);
    return Promise.reject(`创建项目失败!`);
  }
}

/**
 * 更新项目或项目组
 * @param { UpdateProjectQuery } query
 * @returns { Promise<ProjectDetailInfo | void> }
 */
export async function update(query: UpdateProjectQuery): Promise<ProjectDetailInfo | void> {
  try {
    const { thumb, id: projectId, ...rest } = query;

    await request(apis.projectPatch, {
      params: { id: projectId },
      body: rest,
    });
    return await getDetail(projectId);
  } catch (err) {
    console.error('updateProject:', err);
    return Promise.reject(new Error(`更新项目或项目组失败!`));
  }
}

/**
 * 移动项目
 * @param { MoveGroupBaseInfos } query
 * @returns { Promise<void[]> }
 */
export async function moveGroup(query: MoveGroupBaseInfos): Promise<void[]> {
  try {
    const { groupId, ids } = query;

    return await Promise.all(
      ids.map(async (id) => {
        await request(apis.projectPatch, {
          params: {
            id,
          },
          body: {
            groupId,
          },
        });
      }),
    );
  } catch (err) {
    console.error('MoveGroupProject:', err);
    return Promise.reject('移动项目分组失败!');
  }
}

/**
 * 复制项目
 * @param { CopyProjectQuery } query
 * @returns { Promise<CopyProjectData | void> }
 */
export async function copy(
  query: CopyProjectQuery,
  addProjectNamePrefix = true,
): Promise<CopyProjectData | void> {
  try {
    const newProject = await request(apis.projectsCopyPost, {
      params: { id: query.id },
    });

    if (!newProject.projectId) return;

    if (addProjectNamePrefix && query.name) {
      await request(apis.projectPatch, {
        params: { id: newProject.projectId },
        body: { name: `copy ${query.name}` },
      });
    }

    return newProject;
  } catch (err) {
    console.error('copyProject:', err);
    return Promise.reject('复制项目失败!');
  }
}

/**
 * 删除项目
 * @param { RemoveBaseInfos } query
 * @returns { Promise<void> }
 */
export async function remove(query: RemoveBaseInfos): Promise<void> {
  try {
    const { ids } = query;

    return await request(apis.projectsDelete, {
      query: {
        ids,
      },
    });
  } catch (err) {
    console.error('removeProject:', err);
    return Promise.reject('删除项目失败!');
  }
}

/**
 * 恢复项目
 * @param { RecycleBaseInfos } query
 * @returns { Promise<void[]> }
 */
export async function recover(query: RecycleBaseInfos): Promise<void[]> {
  try {
    const { ids } = query;
    return await Promise.all(
      ids.map(async (id) => {
        await request(apis.projectsRecoverPatch, {
          params: {
            id,
          },
        });
      }),
    );
  } catch (err) {
    console.error('recoverProject:', err);
    return Promise.reject('恢复项目失败!');
  }
}

export async function exportProject(query: ExportProjectQuery): Promise<ExportProjectData> {
  try {
    return await request(apis.projectsExportGet, {
      params: { id: query.id },
    });
  } catch (err) {
    console.error('expertProject:', err);
    return Promise.reject('导出项目失败!');
  }
}

export async function importProject(query: ImportProjectQuery): Promise<ImportProjectData> {
  try {
    return await request(apis.projectsImportPost, {
      body: query,
    });
  } catch (err) {
    console.error('importProject:', err);
    return Promise.reject('导入项目失败!');
  }
}