import chumi, {
  Controller,
  Service,
  Get,
  Post,
  Delete,
  Put,
  Param,
  Query,
  Body,
  Header,
  Files,
  ApiTags,
  loadService,
  loadController,
  ChumiRequestData,   // TypeScript Types
  ChumiResponseData,  // TypeScript Types
} from 'chumi';

import Koa, { Context } from 'koa';
import chumi, { Controller, Get, Service, loadController, loadService } from 'chumi';

const app = new Koa();

// Service类
@Service
class S1 {
  ctx: Context;
  chain = loadController(Chain);
  s1 = loadService(S1);
}

// Controller类
@Controller()
class Chain {
  ctx: Context;
  chain = loadController(Chain);
  s1 = loadService(S1);

  async result() {
    return this.ctx.path;
  }

  @Get('/')
  async index() {
    // 支持无限调用下去，不管是在service，还是controller，都是支持的
    return this.chain.chain.s1.s1.chain.chain.s1.s1.chain.chain.s1.s1.chain.chain.result();
  }
}

app.use(chumi([Chain]));

app.listen(9000);

// 核心示例代码
import { ChumiRequestData,ChumiResponseData } from 'chumi';

// 接口通用返回格式，我们往往会用到data
// 这里的data就是对应控制器函数的返回值
export interface ApiResponse<T> {
  ret: 0 | -1;
  msg: string;
  data: T;
}

// 对定义API请求的函数的类型定义
export type ApiFunction<
  T extends abstract new (...args: any) => any,
  S extends keyof InstanceType<T>
> = (...args: ChumiRequestData<T, S>) => Promise<ApiResponse<ChumiResponseData<T, S>>>;

export type ApiResponseData<
  T extends abstract new (...args: any) => any,
  S extends keyof InstanceType<T>
> = (ReturnType<ApiFunction<T, S>> extends Promise<infer U> ? U : never)['data'];

// 使用
// 比如我有导入的控制器类为Ctr1，其上面有一个函数getName
// 那么可以在前端定义如下接口函数
export const getName: ApiFunction<typeof Ctr1, 'getName'> = async (id) => {
  return await request.get(`/api/getName?id=${id}`);
};

// 获取Ctr1控制器里面的getName函数的返回值类型
// 这里返回的数据，将直接提供给前端使用
// 所以在全栈项目中，通过该类型，保证了前后端数据的一致性，提升健壮性
export type getNameData = ApiResponseData<typeof Ctr1, 'getName'>;