import {
  loopHandle,
  ComponentTypeEnum,
  StateTypeEnum,
  ViewpointTypeEnum,
  GetComponenterTreeListQuery,
  FilterComponenterTreeListQuery,
  GetComponenterDetailQuery,
  UpdateComponentQuery,
  MoveComponenterQuery,
  RemoveComponentsQuery,
  RemoveComponentGroupQuery,
  ComponenterData,
  ComponentDetailInfo,
  CreateGroupComponentQuery,
  CopyComponentsQuery,
  ComponentInfo,
  ComponentDetailData,
} from '@easytwin/core';

import apis from '@/constants/api.swagger-constants';
import { request } from '@/utils/request';

export async function getTree(query: GetComponenterTreeListQuery): Promise<ComponentDetailInfo[]> {
  try {
    const { sceneId } = query;

    const list = await request(apis.scenesObjsGet, { params: { sceneId } });

    const attachTags = async (list: ComponentInfo[]): Promise<ComponentDetailInfo[]> => Promise.all(
        list.map(async (item: ComponentInfo) => {
          const componentData: ComponentDetailInfo = await getDetail({ id: item.id, sceneId });
          const {children} = item;
          if (children?.length) {
            return {
              ...componentData,
              children: await attachTags(children),
            };
          }
          return { ...componentData, children: [] };
        }),
      );

    return await attachTags(list as ComponentInfo[]);
  } catch (err) {
    console.error('getComponenterTreeList:', err);
    return Promise.reject(new Error('获取空间对象树失败!'));
  }
}

/**
 * 过滤空间对象树
 * @author xuek
 * @since 2022-01-10
 * @param { FilterComponenterTreeListQuery } query
 * @returns { Promise<ObjDetailVo[]> }
 */
export async function filterTree(query: FilterComponenterTreeListQuery): Promise<ComponentInfo[]> {
  try {
    console.log('=====');

    const { name, tagId } = query;

    //  先获取场景下所有的 Component
    const allComponents = await getTree(query);

    const flatten = (arr: ComponentDetailInfo[]): ComponentDetailInfo[] => arr.reduce((prev: ComponentDetailInfo[], next: ComponentDetailInfo) => prev.concat(
          Array.isArray(next.children) && next.children.length > 0 ? flatten(next.children) : next,
        ), []);

    return flatten(allComponents)
      .filter((value) => !!name && value.name.includes(name))
      .filter((item) => item.tags.some((tag) => tag.id === tagId));
  } catch (err) {
    console.error('filterComponenterTreeList:', err);
    return Promise.reject(new Error('过滤空间对象树失败!'));
  }
}

export async function getDetail(query: GetComponenterDetailQuery): Promise<ComponentDetailInfo> {
  try {
    return (await request(apis.scenesObjGet, {
      params: { id: query.id, sceneId: query.sceneId },
    })) as ComponentDetailInfo;
  } catch (err) {
    console.error('getComponenterDetail:', err);
    return Promise.reject(new Error('获取空间对象详情失败!'));
  }
}

/**
 * 创建空间组对象
 * @author xuek
 * @since 2022-02-17
 * @param { CreateComponenterGroupQuery } query
 * @returns { Promise<ComponenterData ｜ void> }
 */
export async function createGroup(
  query: Omit<CreateGroupComponentQuery, 'name'>,
): Promise<ComponentInfo | null> {
  try {
    const { parentObjId, sceneId, objIds } = query;
    if (!parentObjId) return null;
    const data = await request(apis.scenesObjsGatherPatch, {
      params: { sceneId },
      body: {
        name: '分组',
        parentObjId,
        objIds,
      },
    });
    const tree = await getTree({ sceneId });
    const result = tree.find((item) => item.id === data.objId);
    if (result) return result;
    return null;
  } catch (err) {
    console.error('createComponentergroup:', err);
    return Promise.reject(new Error('创建空间组对象失败!'));
  }
}

/**
 * 复制空间对象
 * @author xuek
 * @since 2021-12-31
 * @param { CopyComponentsQuery } query
 * @returns { Promise<ComponenterData ｜ void> }
 */
export async function copy(query: CopyComponentsQuery): Promise<ComponenterData | void> {
  try {
    const {
      sceneId,
      ids,
      // parentObjId
    } = query;
    return await loopHandle(ids, async (id) => {
      const componenter = await request(apis.scenesObjsCopyPost, { params: { sceneId, id } });
      if (!componenter) return Promise.reject(new Error('复制元件失败!'));
      return componenter;
    });
  } catch (err) {
    console.error('moveComponenter:', err);
    return Promise.reject(new Error('复制空间对象失败!'));
  }
}

/**
 * 批量删除空间对象
 * @author xuek
 * @since 2022-01-10
 * @param { RemoveComponentsQuery } query
 * @returns { Promise<void> }
 */
export async function remove(query: RemoveComponentsQuery): Promise<void> {
  try {
    const { ids, sceneId } = query;

    const result = await request(apis.scenesObjsDelete, {
      params: { sceneId },
      query: { ids },
    });

    return result;
  } catch (err) {
    console.error('removeComponent:', err);
    return Promise.reject(new Error('删除空间对象失败!'));
  }
}

/**
 * 创建空间组对象
 * @author xuek
 * @since 2022-02-17
 * @param { RemoveComponentGroupQuery } query
 * @returns { Promise<void[]> }
 */
export async function removeGroup(query: RemoveComponentGroupQuery) {
  try {
    const { ids } = query;
    // return ids.map(async (id) => {});
    // return await CommonApi.removeByKeys<ComponenterData>(
    //   ComponenterStore,
    //   ids,
    //   async ({ id: removeId, parentObjId }) => {
    //     const childrens = await CommonApi.getList<ComponenterData>(
    //       ComponenterStore,
    //       (value) => value.parentObjId === removeId,
    //     );
    //     await loopHandle(childrens, async ({ id }) => {
    //       await CommonApi.update<ComponenterData, UpdateComponentQuery>(ComponenterStore, {
    //         id,
    //         parentObjId,
    //       });
    //     });
    //     const flowNode = await FlowNodeApi.getByBizId(removeId, FlowNodeTypeEnum.COMPONENTER);
    //     if (!flowNode) return;
    //     await FlowNodeApi.update({
    //       id: flowNode.id,
    //       bizDataDel: true,
    //     });
    //   },
    // );
  } catch (err) {
    console.error('removComponenterGroup:', err);
    return Promise.reject(new Error('删除空间对象失败!'));
  }
}