import {
  Body,
  Controller,
  Delete,
  Get,
  Put,
  Path,
  Post,
  Query,
  Request,
  Route,
  Security,
  Tags,
} from "tsoa";
import { Prisma, Status } from "@prisma/client";

import prisma from "../db";
import { RequestWithUser } from "../interfaces/user";
import HttpStatus from "../interfaces/http-status";
import { isUsedError, notFoundError } from "../utils/error";
import { whereDateQuery } from "../utils/relation";

type WorkCreate = {
  order: number;
  name: string;
  attributes?: {
    [key: string]: any;
  };
};

type WorkUpdate = {
  order?: number;
  name?: string;
  attributes?: {
    [key: string]: any;
  };
};

@Route("api/v1/work")
@Tags("Work")
@Security("keycloak")
export class WorkController extends Controller {
  @Get()
  async getWork(
    @Query() baseOnly?: boolean,
    @Query() query: string = "",
    @Query() page: number = 1,
    @Query() pageSize: number = 30,
    @Query() startDate?: Date,
    @Query() endDate?: Date,
  ) {
    const where = {
      OR: [{ name: { contains: query }, serviceId: baseOnly ? null : undefined }],
      ...whereDateQuery(startDate, endDate),
    } satisfies Prisma.WorkWhereInput;

    const [result, total] = await prisma.$transaction([
      prisma.work.findMany({
        include: {
          productOnWork: {
            include: { product: true },
            orderBy: { order: "asc" },
          },
          createdBy: true,
          updatedBy: true,
        },
        orderBy: { createdAt: "asc" },
        where,
        take: pageSize,
        skip: (page - 1) * pageSize,
      }),
      prisma.work.count({ where }),
    ]);

    return { result, page, pageSize, total };
  }

  @Get("{workId}")
  async getWorkById(@Path() workId: string) {
    const record = await prisma.work.findFirst({
      where: { id: workId },
    });

    if (!record) throw notFoundError("Work");

    return record;
  }

  @Get("{workId}/product")
  async getProductOfWork(
    @Path() workId: string,
    @Query() query: string = "",
    @Query() page: number = 1,
    @Query() pageSize: number = 30,
  ) {
    const where = {
      AND: [{ workProduct: { some: { workId } } }, { OR: [{ name: { contains: query } }] }],
    } satisfies Prisma.ProductWhereInput;

    const [result, total] = await prisma.$transaction([
      prisma.product.findMany({
        include: {
          createdBy: true,
          updatedBy: true,
        },
        where,
        take: pageSize,
        skip: (page - 1) * pageSize,
      }),
      prisma.product.count({
        where,
      }),
    ]);

    return { result, page, pageSize, total };
  }

  @Post()
  async createWork(@Request() req: RequestWithUser, @Body() body: WorkCreate) {
    const exist = await prisma.work.findFirst({
      where: {
        name: body.name,
        productOnWork: { none: {} },
      },
    });

    if (exist) return exist;

    const record = await prisma.work.create({
      include: {
        createdBy: true,
        updatedBy: true,
      },
      data: {
        ...body,
        createdByUserId: req.user.sub,
        updatedByUserId: req.user.sub,
      },
    });

    this.setStatus(HttpStatus.CREATED);

    return record;
  }

  @Put("{workId}")
  async editWork(
    @Request() req: RequestWithUser,
    @Body() body: WorkUpdate,
    @Path() workId: string,
  ) {
    const work = await prisma.work.findUnique({ where: { id: workId } });

    if (!work) throw notFoundError("Work");

    const exist = await prisma.work.findFirst({
      where: {
        id: { not: workId },
        name: body.name,
        productOnWork: { none: {} },
      },
    });

    if (exist) return exist;

    const record = await prisma.work.update({
      include: {
        createdBy: true,
        updatedBy: true,
      },
      where: { id: workId },
      data: { ...body, updatedByUserId: req.user.sub },
    });

    return record;
  }

  @Delete("{workId}")
  async deleteWork(@Path() workId: string) {
    const record = await prisma.work.findFirst({
      include: { createdBy: true, updatedBy: true },
      where: { id: workId },
    });

    if (!record) throw notFoundError("Work");
    if (record.status !== Status.CREATED) throw isUsedError("Work");

    return await prisma.work.delete({ where: { id: workId } });
  }
}