import { FastifyInstance, FastifyReply, FastifyRequest } from 'fastify'
import { PaymentService } from '../services/payment.service'
import {
  CreatePaymentParams,
  PaymentNotifyParams,
  CreatePaymentOrderParams,
  UserQueryOrderParams,
  CreateSinglePaymentOrderParams,
  SingleQueryParams,
  SingleListQueryParams
} from '../dto/payment.dto'

export class PaymentController {
  private paymentService: PaymentService

  constructor(app: FastifyInstance) {
    this.paymentService = new PaymentService(app)
  }

  async createPaymentOrder(request: FastifyRequest<{ Body: CreatePaymentOrderParams }>, reply: FastifyReply) {
    try {
      const { userId, type } = request.body
      const ip = request.ip

      if (!userId || !type) {
        return reply.code(400).send({
          message: '缺少字段'
        })
      }

      const validTypes = ['single', 'hourly', 'daily', 'weekly', 'monthly', 'quarterly', 'yearly', 'lifetime']
      if (!validTypes.includes(type)) {
        return reply.code(400).send({
          message: '不支持的订单类型'
        })
      }

      const result = await this.paymentService.createPaymentOrder({ userId, type, ip })
      return reply.send(result)
    } catch (error) {
      return reply.code(500).send({ message: '创建支付订单失败', error })
    }
  }

  async createSinglePaymentOrder(
    request: FastifyRequest<{ Body: CreateSinglePaymentOrderParams }>,
    reply: FastifyReply
  ) {
    try {
      const { resourceId, userId } = request.body
      const ip = request.ip

      if (!userId || !resourceId) {
        return reply.code(400).send({
          message: '缺少字段'
        })
      }

      const result = await this.paymentService.createSinglePaymentOrder({ resourceId, userId, ip })
      return reply.send(result)
    } catch (error) {
      return reply.code(500).send({ message: '创建单片购买订单失败', error })
    }
  }

  async notifyOrder(request: FastifyRequest<{ Querystring: PaymentNotifyParams }>, reply: FastifyReply) {
    try {
      await this.paymentService.handlePaymentNotify(request.query)
      return reply.send('success')
    } catch (error) {
      return reply.code(500).send('Failed to handle payment notification')
    }
  }

  async queryOrder(
    request: FastifyRequest<{
      Querystring: {
        trade_no?: string
        out_trade_no?: string
      }
    }>,
    reply: FastifyReply
  ) {
    try {
      const { trade_no, out_trade_no } = request.query

      if (!trade_no && !out_trade_no) {
        return reply.code(400).send({
          message: 'trade_no and out_trade_no are required'
        })
      }

      const result = await this.paymentService.queryOrder({ trade_no, out_trade_no })
      return reply.send(result)
    } catch (error) {
      return reply.code(500).send('Failed to query payment order')
    }
  }

  async userQueryOrder(request: FastifyRequest<{ Querystring: UserQueryOrderParams }>, reply: FastifyReply) {
    try {
      const user = request.user
      const { orderNo, resourceId } = request.query
      const result = await this.paymentService.userQueryOrder(user.id, orderNo, resourceId)
      return reply.send(result)
    } catch (error) {
      return reply.code(500).send('Failed to query user order')
    }
  }

  async userSingleQuery(request: FastifyRequest<{ Querystring: SingleQueryParams }>, reply: FastifyReply) {
    try {
      const user = request.user
      const { resourceId } = request.query
      const result = await this.paymentService.userSingleQuery(user.id, resourceId)
      return reply.send(result)
    } catch (error) {
      return reply.code(500).send('Failed to query user single query')
    }
  }

  async userSingleList(request: FastifyRequest<{ Querystring: SingleListQueryParams }>, reply: FastifyReply) {
    try {
      const user = request.user
      const { page = 0, size = 20, resourceId } = request.query
      const result = await this.paymentService.userSingleList(user.id, { page, size, resourceId })
      return reply.send(result)
    } catch (error) {
      return reply.code(500).send('Failed to query user single list')
    }
  }
}