import moment from "moment";
import createAxiosInstance from "./axios";
// 路网
const { get, post } = createAxiosInstance({ baseUrl: "/api", timeout: 60000 });
export type tableServer = {
  category?: string;
  creatorUid?: string;
  remark?: string;
  tableAlias?: string;
  tableName?: string;
  tableType?: string;
  uid: string;
  timeGranularity?: string;
};
/**
 * 工作表字段
 */
export type tableFieldServer = {
  creatorUid?: string;
  dataType?: number;
  fieldAlias?: string;
  fieldName?: string;
  functionType?: number;
  maxLength?: number;
  remark?: string;
  tableUid?: string;
  uid: string;
};
export enum TableType {
  路网特征表 = 1,
  地理信息表 = 2,
  业务原始表 = 3,
  统计结果表 = 4,
  其他 = 5,
}

export enum TableFieldFunctionType {
  值 = 1,
  查询条件 = 2,
  时序 = 3,
  单元uid = 4,
  其他 = 5,
}

export enum TableFieldDataType {
  string = 1,
  int = 2,
  datetime = 3,
  boolean = 4,
  wkt = 5,
}

const api = {
  area: {
    /**
     * 根据区域uid查询区域的子区域列表
     * @param areaUid
     */
    queryAreaByParentUid<T>(areaUid: string) {
      return get<T>("area/queryAreaByParentUid", {
        parentUid: areaUid,
        depth: 1,
        excludeFieldList: "simple_polygon,area_line_text,area_point_text",
      });
    },
    /**
     * 根据Uid查询区域
     * @param areaUid 区域Uid
     */
    queryAreaByUid<T>(areaUid: string) {
      return get<T>("/area/queryAreaByUid", {
        areaUid,
      });
    },
    /**
     * 根据父区域Uid查询区域
     * @param parentAreaUid
     */
    selectRelationByParentAreaUid<T>(parentAreaUid: string) {
      return get<T>("/area/selectRelationByParentAreaUid", {
        parentAreaUid,
      });
    },
    // 从本地json文件加载所有地区信息
    queryAreaFromJsonByUid(areaUid: string) {
      return get("../area/" + areaUid + ".json");
    },
  },
  segment: {
    querySegment<T>(segmentUidList: string[]) {
      return post<T>("/road/segment/querySegment", segmentUidList);
    },
    /**
     *
     * @param noNeedSegmentUidList 不需要返回的路段uid集合
     * @param roadTypeList 路段类型list
     * @param wkt WKT文本
     */
    querySegmentListByWKT<T>(p: { noNeedSegmentUidList: string[]; roadTypeList: number[]; wkt: string }) {
      return post<T>(`/road/segment/querySegmentListByWKT`, {
        noNeedSegmentUidList: p.noNeedSegmentUidList,
        roadTypeList: p.roadTypeList,
        wkt: p.wkt,
      });
    },

    /**
     * 根据bounds查询经纬度
     * @param p
     */
    querySegmentListByBounds<T>(p: {
      startPoint: {
        latitude: number;
        longitude: number;
      };
      endPoint: {
        latitude: number;
        longitude: number;
      };
      noNeedSegmentUidList: string[];
      roadTypeList: number[];
    }) {
      return post<T>(`/road/segment/v2/querySegmentListByRange`, p);
    },
  },
  point: {
    queryControlPointsByBounds<T>(p: {
      startPoint: {
        latitude: number;
        longitude: number;
      };
      endPoint: {
        latitude: number;
        longitude: number;
      };
      probability?: number;
      typeList?: number[];
    }) {
      return post<T>(`/control/point/query`, p);
    },
  },
  poi: {
    queryByWKT(wkt: string) {
      return post("/poi/queryByWKT", {
        wkt,
      });
    },
  },
  road: {
    queryRoad<T>(roadUid: string) {
      return get<T>("/road/queryRoad", {
        roadUid,
      });
    },
  },
  table: {
    addMetaTable(params: tableServer) {
      return post("/meta/table/addMetaTable", params);
    },
    queryByCondition(
      categoryList: string[] = [],
      creatorUidList: string[] = [],
      tableTypeList: string[] = [],
      workTableUidList: string[] = []
    ) {
      return post("/meta/table/queryByCondition", {
        categoryList,
        creatorUidList,
        tableTypeList,
        workTableUidList,
      }) as Promise<tableServer[]>;
    },
    loadTableByUid(tableUid: string) {
      return post("/meta/table/queryByCondition", {
        workTableUidList: [tableUid],
      }) as Promise<tableServer[]>;
    },

    loadFieldsByTableUid(tableUid: string) {
      return post("/meta/field/queryListByCondition", {
        tableUidList: [tableUid],
      }) as Promise<tableFieldServer[]>;
    },
    async getCommonTable<T>(
      tableUid: string,
      filter: {
        filterTimeKey?: string;
        filterTime?: string;
        filterAreaCodeKey?: string;
        filterAreaCode?: string;
        filterAreaNameKey?: string;
        filterAreaName?: string;
      } = {},
      eqFilters: {
        [filterKey: string]: any;
      } = {}
    ) {
      const conditionList = [];
      if (filter.filterTime && filter.filterTimeKey) {
        conditionList.push({
          fieldName: filter.filterTimeKey,
          operator: "BETWEEN",
          value: [
            moment(filter.filterTime).startOf("day").format("YYYY-MM-DD HH:mm:ss"),
            moment(filter.filterTime).endOf("day").format("YYYY-MM-DD HH:mm:ss"),
          ],
        });
      }
      if (filter.filterAreaCode && filter.filterAreaCodeKey) {
        conditionList.push({
          fieldName: filter.filterAreaCodeKey,
          operator: "EQ",
          value: [filter.filterAreaCode],
        });
      }
      if (filter.filterAreaName && filter.filterAreaNameKey) {
        conditionList.push({
          fieldName: filter.filterAreaNameKey,
          operator: "EQ",
          value: [filter.filterAreaName],
        });
      }
      if (eqFilters) {
        for (const key in eqFilters) {
          if (eqFilters[key]) {
            conditionList.push({
              fieldName: key,
              operator: "EQ",
              value: [eqFilters[key]],
            });
          }
        }
      }
      const result: OriginTableData = await post(`/data/search`, {
        fieldList: [],
        conditionList,
        pageIndex: 1,
        pageSize: 50000,
        sortList: [],
        tableUid: tableUid,
      });
      return formatOriginData<T>(result);
    },
    // queryFieldByUid(uid: string) {
    //   return post("/meta/field/queryListByCondition", {
    //     uid,
    //   });
    // },
  },
};
export interface OriginTableData {
  // 表id
  fieldList: TableField[];
  recordList: TableColumns[];
}
export interface TableField {
  creatorUid: string;
  dataType: number;
  fieldAlias: string;
  fieldName: string;
  functionType: number;
  maxLength: number;
  remark: string;
  tableUid: string;
  uid: string;
}

/**
 * 通用数据查询表信息
 */
export interface TableColumns {
  columns: (number | string)[];
}
const formatOriginData = <T>(data: OriginTableData) => {
  const { recordList, fieldList } = data;
  return recordList.map((row) => {
    const columns: any = {};
    fieldList.forEach((field, index) => {
      columns[field.fieldName] = row.columns[index];
    });
    return columns;
  }) as T[];
};

export default api;