import './service/mini/minidev';
import baseInvokeLocalFunction from './service/cloud_function/invokeLocalFunction';
import miniAppListService from './service/mini/app.list';
import {
  MiniUploadVersion,
  getUploadVersion as getUploadVersionService,
} from './service/mini/util';
import miniPreviewService, { MiniPreviewOptions } from './service/mini/preview';
import miniUploadService, { MiniUploadOptions } from './service/mini/upload';
import miniServiceLocalBuild, { MiniBuildOptions } from './service/mini/build';
import cloudSpaceListService from './service/cloud/space.list';
import cloudFunctionListService, { CloudFunctionListOptions } from './service/cloud/function.list';
import downloadCloudFunctionService, {
  DownloadCloudFunctionOptions,
} from './service/cloud/download.function';
import deployCloudFunctionService, {
  DeployCloudFunctionOptions,
} from './service/cloud/deploy.function';
import {
  createKey as createKeyService,
  matchKey as matchKeyService,
  convertKey as convertKeyService,
  CreateKeyOptions,
  CreateKeyResult,
  ConvertKeyOptions,
} from './service/keytool';
import postLog from './service/post.log';
import {
  getAuthCode as getAuthCodeService,
  GetAuthCodeOptions,
} from './service/mini/workbench/auth';
import updateFunctionHttpTriggerService, {
  CloudFunctionHttpTriggerOptions,
} from './service/cloud/httptrigger.function';

export { setConfig } from './service/config';
export { login } from './service/login';

import baseRequestDep from './utils/base.request';
import requestDep from './utils/request';

export const baseRequest = baseRequestDep;
export const request = requestDep;
export { getMinidev } from './service/mini/minidev';

interface InvokeLocalFunctionOptions {
  /**
   * 小程序appId
   */
  appId: string;
  /**
   * 空间id
   */
  spaceId: string;
  /**
   * 函数根目录
   */
  project: string;
  /**
   * 函数名称
   */
  name: string;
  /**
   * 函数参数
   */
  functionArgs?: object;
}

/**
 * 获取可以开发的小程序列表
 */
export function miniAppList() {
  postLog({
    action: 'MINI_LIST',
  });

  return miniAppListService();
}

/**
 * 本地小程序代码预览
 * options 构建详情
 * showErrorDetail 是否显示错误详情，默认为false ｜ undefined
 */
export async function miniPreview(options: MiniPreviewOptions, showErrorDetail?: boolean) {
  postLog({
    action: 'MINI_PREVIEW',
    appId: options.appId,
  });

  const previewResult = await miniPreviewService(options);
  if (previewResult.stat === 'failed' && !showErrorDetail) {
    delete previewResult.data;
  }
  return previewResult;
}

/**
 * 本地小程序构建
 * @deprecated
 */
export async function miniLocalBuild(options: MiniBuildOptions) {
  await miniServiceLocalBuild(options);
}

/**
 * 获取最近上传的版本号
 */
export function getUploadVersion(options: MiniUploadVersion) {
  postLog({
    action: 'MINI_UPLOAD_VERSION',
    appId: options.appId,
  });

  return getUploadVersionService(options);
}

/**
 * 上传小程序
 */
export async function miniUpload(options: MiniUploadOptions) {
  postLog({
    action: 'MINI_UPLOAD',
    appId: options.appId,
  });
  try {
    const result = await miniUploadService(options);

    // 设置了体验版本
    if (result.qrCodeUrl) {
      postLog({
        action: 'MINI_EXPERIENCE',
        appId: options.appId,
      });
    }

    return result;
  } catch (e) {
    console.log('upload mini app error');
    throw e;
  }
}

/**
 * 获取云环境列表
 */
export function cloudSpaceList(appId: string) {
  postLog({
    action: 'CLOUD_SPACE_LIST',
    appId: appId,
  });

  return cloudSpaceListService(appId);
}

/**
 * 获取空间下的云函数列表
 */
export function cloudFunctionList(options: CloudFunctionListOptions) {
  postLog({
    action: 'CLOUD_FUNCTION_LIST',
    appId: options.appId,
  });

  return cloudFunctionListService(options);
}

/**
 * 下载云函数
 */
export function downloadCloudFunction(options: DownloadCloudFunctionOptions) {
  postLog({
    action: 'CLOUD_FUNCTION_DOWNLOAD',
    appId: options.appId,
  });

  return downloadCloudFunctionService(options);
}

/**
 * 上传云函数
 */
export function deployCloudFunction(options: DeployCloudFunctionOptions) {
  postLog({
    action: 'CLOUD_FUNCTION_DEPLOY',
    appId: options.appId,
  });

  return deployCloudFunctionService(options);
}

/**
 * 调用本地云函数
 */
export function invokeLocalFunction(options: InvokeLocalFunctionOptions) {
  postLog({
    action: 'CLOUD_FUNCTION_LOCAL',
    appId: options.appId,
  });

  return baseInvokeLocalFunction(options);
}

/**
 * 开启或者关闭云函数的http触发器
 */
export function updateFunctionHttpTrigger(options: CloudFunctionHttpTriggerOptions) {
  postLog({
    action: 'CLOUD_FUNCTION_HTTP',
    appId: options.appId,
  });

  return updateFunctionHttpTriggerService(options);
}

interface InvokeCloudFunctionOptions {
  /**
   * 阿里云serverSecret
   */
  serverSecret: string;
  /**
   * 空间id
   */
  spaceId: string;
  /**
   * 函数根目录
   */
  project: string;
  /**
   * 函数名称
   */
  name: string;
  /**
   * 函数参数
   */
  functionArgs?: object;
}

/**
 * 直接用阿里云serverSecret调用
 */
export function invokeCloudFunction(options: InvokeCloudFunctionOptions) {
  postLog({
    action: 'CLOUD_FUNCTION_SECRET',
  });

  return baseInvokeLocalFunction(options);
}

/**
 * 生成密钥
 */
export function createKey(options?: CreateKeyOptions) {
  postLog({
    action: 'KEY_CREATE',
  });

  return createKeyService(options);
}

/**
 * 密钥匹配检测
 */
export function matchKey(options: CreateKeyResult) {
  postLog({
    action: 'KEY_MATCH',
  });
  return matchKeyService(options);
}

/**
 * 密钥转换
 */
export function convertKey(options: ConvertKeyOptions) {
  postLog({
    action: 'KEY_CONVERT',
  });

  return convertKeyService(options);
}

export const workbench = {
  /**
   * 获取授权码
   */
  getAuthCode(options: GetAuthCodeOptions) {
    postLog({
      action: 'MINI_GET_AUTH_CODE',
      appId: options.appId,
    });

    return getAuthCodeService(options);
  },
};