import {
  Controller,
  Post,
  Get,
  Body,
  Inject,
  Del,
  Param,
  Query,
  Put,
} from '@midwayjs/core';
import { StockService } from '../service/stock.service';
import { errorResponse, successResponse } from '../utils/response.util';
import {
  CreatePurchaseOrderDTO,
  CreateStockPointDTO,
  QueryPointDTO,
  QueryPurchaseOrderDTO,
  QueryStockDTO,
  QueryStockRecordDTO,
  UpdatePurchaseOrderDTO,
  UpdateStockDTO,
  UpdateStockPointDTO,
} from '../dto/stock.dto';
import { ApiOkResponse } from '@midwayjs/swagger';
import {
  BooleanRes,
  PurchaseOrderListRes,
  StockListRes,
  StockPointAllRespone,
  StockPointListRes,
  StockRecordListRes,
} from '../dto/reponse.dto';
import { User } from '../decorator/user.decorator';

@Controller('/stock')
export class StockController {
  @Inject()
  private readonly stockService: StockService;

  @ApiOkResponse({ type: BooleanRes, description: '创建库存点' })
  @Post('/stock-point')
  async createStockPoint(@Body() body: CreateStockPointDTO) {
    try {
      const data = await this.stockService.createStockPoint(body);
      return successResponse(data);
    } catch (error) {
      return errorResponse(error?.message || '获取库存列表失败');
    }
  }

  @ApiOkResponse({ type: BooleanRes, description: '创建库存点' })
  @Put('/stock-point/:id')
  async updateStockPoint(
    @Param('id') id: number,
    @Body() body: UpdateStockPointDTO
  ) {
    try {
      const data = await this.stockService.updateStockPoint(id, body);
      return successResponse(data);
    } catch (error) {
      return errorResponse(error?.message || '获取库存列表失败');
    }
  }

  @ApiOkResponse({ type: StockPointListRes, description: '获取库存点列表' })
  @Get('/stock-point')
  async getStockPoints(@Query() query: QueryPointDTO) {
    try {
      const data = await this.stockService.getStockPoints(query);
      return successResponse(data);
    } catch (error) {
      return errorResponse(error?.message || '获取库存列表失败');
    }
  }

  @ApiOkResponse({ type: StockPointAllRespone, description: '获取所有库存' })
  @Get('/stock-point/all')
  async getAllStockPoints() {
    try {
      const data = await this.stockService.getAllStockPoints();
      return successResponse(data);
    } catch (error) {
      return errorResponse(error?.message || '获取失败');
    }
  }

  @ApiOkResponse({ type: BooleanRes, description: '删除库存点' })
  @Del('/stock-point/:id')
  async delStockPoints(@Param('id') id: number) {
    try {
      await this.stockService.delStockPoints(id);
      return successResponse(true);
    } catch (error) {
      return errorResponse(error?.message || '删除库存点失败');
    }
  }

  @ApiOkResponse({ type: BooleanRes })
  @Post('/purchase-order')
  async createPurchaseOrder(@Body() body: CreatePurchaseOrderDTO) {
    try {
      const data = await this.stockService.createPurchaseOrder(body);
      return successResponse(data);
    } catch (error) {
      return errorResponse(error?.message || '创建失败');
    }
  }

  @ApiOkResponse({ type: BooleanRes })
  @Put('/purchase-order/:id')
  async updatePurchaseOrder(
    @Param('id') id: number,
    @Body() body: UpdatePurchaseOrderDTO
  ) {
    try {
      const data = await this.stockService.updatePurchaseOrder(id, body);
      return successResponse(data);
    } catch (error) {
      return errorResponse(error?.message || '更新失败');
    }
  }

  @ApiOkResponse({ type: PurchaseOrderListRes, description: '获取采购列表' })
  @Get('/purchase-order')
  async getPurchaseOrders(@Query() query: QueryPurchaseOrderDTO) {
    try {
      const data = await this.stockService.getPurchaseOrders(query);
      return successResponse(data);
    } catch (error) {
      return errorResponse(error?.message || '获取库存记录列表失败');
    }
  }

  @ApiOkResponse({ type: BooleanRes })
  @Del('/purchase-order/:id')
  async delPurchaseOrder(@Param('id') id: number) {
    try {
      const data = await this.stockService.delPurchaseOrder(id);
      return successResponse(data);
    } catch (error) {
      return errorResponse(error?.message || '删除失败');
    }
  }

  @ApiOkResponse({ type: BooleanRes })
  @Post('/purchase-order/:id')
  async receivePurchaseOrder(@Param('id') id: number, @User() user) {
    try {
      const data = await this.stockService.receivePurchaseOrder(id, user.id);
      return successResponse(data);
    } catch (error) {
      return errorResponse(error?.message || '更新失败');
    }
  }

  @ApiOkResponse({ type: StockListRes, description: '获取库存列表' })
  @Get('/')
  async getStocks(@Query() query: QueryStockDTO) {
    try {
      const data = await this.stockService.getStocks(query);
      return successResponse(data);
    } catch (error) {
      return errorResponse(error?.message || '获取库存列表失败');
    }
  }

  @ApiOkResponse({
    type: BooleanRes,
    description: '更新库存（入库、出库、调整）',
  })
  @Post('/update')
  async updateStock(@Body() body: UpdateStockDTO) {
    try {
      await this.stockService.updateStock(body);
      return successResponse(true);
    } catch (error) {
      return errorResponse(error?.message || '更新库存失败');
    }
  }

  @ApiOkResponse({ type: StockRecordListRes, description: '获取库存记录列表' })
  @Get('/records')
  async getStockRecords(@Query() query: QueryStockRecordDTO) {
    try {
      const data = await this.stockService.getStockRecords(query);
      return successResponse(data);
    } catch (error) {
      return errorResponse(error?.message || '获取库存记录列表失败');
    }
  }

  @ApiOkResponse({ type: BooleanRes })
  @Post('/transfer')
  async createTransfer(@Body() body: Record<string, any>, @User() user) {
    try {
      const data = await this.stockService.createTransfer(body, user.id);
      return successResponse(data);
    } catch (error) {
      return errorResponse(error?.message || '创建失败');
    }
  }

  @ApiOkResponse()
  @Get('/transfer')
  async getTransfers(@Query() query: Record<string, any>) {
    try {
      const data = await this.stockService.getTransfers(query);
      return successResponse(data);
    } catch (error) {
      return errorResponse(error?.message || '获取调拨列表失败');
    }
  }

  @ApiOkResponse({ type: BooleanRes })
  @Post('/cancelTransfer/:id')
  async cancelTransfer(@Param('id') id: number, @User() user) {
    try {
      const data = await this.stockService.cancelTransfer(id, user.id);
      return successResponse(data);
    } catch (error) {
      return errorResponse(error?.message || '删除失败');
    }
  }

  @ApiOkResponse({ type: BooleanRes })
  @Post('/receiveTransfer/:id')
  async receiveTransfer(@Param('id') id: number, @User() user) {
    try {
      const data = await this.stockService.receiveTransfer(id, user.id);
      return successResponse(data);
    } catch (error) {
      return errorResponse(error?.message || '更新失败');
    }
  }

  @ApiOkResponse({ type: BooleanRes })
  @Post('/lostTransfer/:id')
  async lostTransfer(@Param('id') id: number) {
    try {
      const data = await this.stockService.lostTransfer(id);
      return successResponse(data);
    } catch (error) {
      return errorResponse(error?.message || '更新失败');
    }
  }

  @ApiOkResponse({ type: BooleanRes })
  @Put('/receiveTransfer/:id')
  async updateTransfer(
    @Param('id') id: number,
    @Body() body: Record<string, any>,
    @User() user
  ) {
    try {
      const data = await this.stockService.updateTransfer(id, body, user.id);
      return successResponse(data);
    } catch (error) {
      return errorResponse(error?.message || '更新失败');
    }
  }
}