import { Repository, Like } from 'typeorm'
import { FastifyInstance } from 'fastify'
import { SmsTask } from '../entities/sms-task.entity'
import { PaginationResponse } from '../dto/common.dto'
import { CreateSmsTaskBody, UpdateSmsTaskBody, ListSmsTaskQuery } from '../dto/sms-task.dto'
import { TaskStatus } from '../enum/task.enum'

export class SmsTaskService {
  private smsTaskRepository: Repository<SmsTask>

  constructor(app: FastifyInstance) {
    this.smsTaskRepository = app.dataSource.getRepository(SmsTask)
  }

  async create(data: CreateSmsTaskBody): Promise<SmsTask> {
    const task = this.smsTaskRepository.create({
      userId: data.userId,
      name: data.name,
      message: data.message,
      remark: data.remark,
      delFlag: false
    })
    return this.smsTaskRepository.save(task)
  }

  async findById(id: number): Promise<SmsTask> {
    return this.smsTaskRepository.findOneOrFail({
      where: { id, delFlag: false }
    })
  }

  async findAll(query: ListSmsTaskQuery): Promise<PaginationResponse<SmsTask>> {
    const { page = 0, size = 20, userId, status, name } = query

    const where: any = {
      delFlag: false
    }

    if (userId) {
      where.userId = userId
    }

    if (status) {
      where.status = status
    }

    if (name) {
      where.name = Like(`%${name}%`)
    }

    const [tasks, total] = await this.smsTaskRepository.findAndCount({
      where,
      skip: Number(page) * Number(size),
      take: Number(size),
      order: {
        createdAt: 'DESC'
      }
    })

    return {
      content: tasks,
      metadata: {
        total: Number(total),
        page: Number(page),
        size: Number(size)
      }
    }
  }

  async update(id: number, data: UpdateSmsTaskBody): Promise<SmsTask> {
    const task = await this.findById(id)

    const updateData: Partial<SmsTask> = {}
    if (data.name !== undefined) updateData.name = data.name
    if (data.message !== undefined) updateData.message = data.message
    if (data.status !== undefined) updateData.status = data.status
    if (data.processed !== undefined) updateData.processed = data.processed
    if (data.successed !== undefined) updateData.successed = data.successed
    if (data.total !== undefined) updateData.total = data.total
    if (data.startedAt !== undefined) updateData.startedAt = data.startedAt
    if (data.remark !== undefined) updateData.remark = data.remark

    await this.smsTaskRepository.update(id, updateData)
    return this.findById(id)
  }

  async delete(id: number): Promise<void> {
    const task = await this.findById(id)
    await this.smsTaskRepository.update(id, { delFlag: true })
  }
}