import {
  Controller,
  Get,
  Post,
  Body,
  Patch,
  Param,
  Delete,
  UsePipes,
  ValidationPipe,
  Res,
  HttpStatus,
  Query,
  NotFoundException,
  BadRequestException,
  UseGuards,
} from '@nestjs/common';
import { AppUsersStepsService } from './app_users_steps.service';
import { CreateAppUsersStepDto } from './dto/create-app_users_step.dto';
import { InjectRepository } from '@nestjs/typeorm';
import { ApiLog } from 'src/api-logs/entities/api-log.entity';
import { DataSource, Repository } from 'typeorm';
import {
  errorResponse,
  successResponse,
  validationErrorMessage,
} from 'src/common/errors/response-config';
import { Response as ExpressResponse } from 'express';
import { lan } from 'src/lan';
import { saveError } from 'src/api-logs/api-error-log';
import { AuthMiddleware } from 'src/common/middleware/auth.middleware';
import { MultipleAppUsersStepDto } from './dto/multiple-app_users_step.dto';

@Controller('app-users-steps')
export class AppUsersStepsController {
  constructor(
    private readonly appUsersStepsService: AppUsersStepsService,
    @InjectRepository(ApiLog)
    private readonly apiLogRepository: Repository<ApiLog>,
    private readonly connection: DataSource,
  ) {}

  @Post()
  @UseGuards(AuthMiddleware)
  @UsePipes(
    new ValidationPipe({
      exceptionFactory: validationErrorMessage,
      transform: true,
      transformOptions: {
        enableImplicitConversion: true,
      },
    }),
  )
  async create(
    @Body() createAppUsersStepDto: CreateAppUsersStepDto,
    @Res() res: ExpressResponse,
  ) {
    const queryRunner = this.connection.createQueryRunner();

    try {
      await queryRunner.connect();
      await queryRunner.startTransaction();
      await this.appUsersStepsService.create(
        createAppUsersStepDto,
        queryRunner.manager,
      );

      await queryRunner.commitTransaction();
      await this.appUsersStepsService.updateTodayStreak(
        createAppUsersStepDto.app_user_id,
      );

      res.send(successResponse(201, lan('common.request_submitted')));
    } catch (error) {
      if (
        error instanceof NotFoundException ||
        error instanceof BadRequestException
      ) {
        res
          .status(HttpStatus.BAD_REQUEST)
          .send(errorResponse(404, error.message));
      } else {
        res
          .status(HttpStatus.INTERNAL_SERVER_ERROR)
          .send(errorResponse(500, lan('common.internal_server_error'), error));
      }

      saveError(error, this.apiLogRepository);
    } finally {
      await queryRunner.release();
    }
  }

  @Post('multiple-steps')
  @UseGuards(AuthMiddleware)
  @UsePipes(
    new ValidationPipe({
      exceptionFactory: validationErrorMessage,
      transform: true,
      transformOptions: {
        enableImplicitConversion: true,
      },
    }),
  )
  async createMultipleSteps(
    @Body() multipleAppUsersStepDto: MultipleAppUsersStepDto,
    @Res() res: ExpressResponse,
  ) {
    const queryRunner = this.connection.createQueryRunner();

    try {
      await queryRunner.connect();
      await queryRunner.startTransaction();
      await this.appUsersStepsService.createMultipleUserSteps(
        multipleAppUsersStepDto,
        queryRunner.manager,
      );
      await queryRunner.commitTransaction();
      await this.appUsersStepsService.updateMultipleStreaks(
        multipleAppUsersStepDto.app_user_id,
      );

      res.send(successResponse(201, lan('common.request_submitted')));
    } catch (error) {
      saveError(error, this.apiLogRepository);

      if (
        error instanceof NotFoundException ||
        error instanceof BadRequestException
      ) {
        res
          .status(HttpStatus.BAD_REQUEST)
          .send(errorResponse(404, error.message));
      } else {
        res
          .status(HttpStatus.INTERNAL_SERVER_ERROR)
          .send(errorResponse(500, lan('common.internal_server_error'), error));
      }
    } finally {
      await queryRunner.release();
    }
  }

  @Get()
  @UseGuards(AuthMiddleware)
  async findAll(
    @Query('take') take: number,
    @Query('skip') skip: number,
    @Res() res: ExpressResponse,
  ) {
    try {
      const userStepsList = await this.appUsersStepsService.findAll(take, skip);
      if (userStepsList) {
        res
          .status(HttpStatus.OK)
          .send(
            successResponse(
              200,
              lan('common.data_retrieved_successfully'),
              userStepsList,
            ),
          );
      }
    } catch (error) {
      res
        .status(HttpStatus.INTERNAL_SERVER_ERROR)
        .send(errorResponse(500, lan('common.internal_server_error'), error));

      saveError(error, this.apiLogRepository);
    }
  }

  @Get(':id')
  @UseGuards(AuthMiddleware)
  async findOne(@Param('id') id: string, @Res() res: ExpressResponse) {
    try {
      const userStep = await this.appUsersStepsService.findOne(id);

      if (userStep) {
        res
          .status(HttpStatus.OK)
          .send(
            successResponse(
              200,
              lan('common.data_retrieved_successfully'),
              userStep,
            ),
          );
      }
    } catch (error) {
      if (
        error instanceof NotFoundException ||
        error instanceof BadRequestException
      ) {
        res
          .status(HttpStatus.BAD_REQUEST)
          .send(errorResponse(404, error.message));
      } else {
        res
          .status(HttpStatus.INTERNAL_SERVER_ERROR)
          .send(errorResponse(500, lan('common.internal_server_error'), error));
      }

      saveError(error, this.apiLogRepository);
    }
  }

  @Get(':id/last-record')
  @UseGuards(AuthMiddleware)
  async findUserLastRecord(
    @Param('id') id: string,
    @Res() res: ExpressResponse,
  ) {
    try {
      const userStep = await this.appUsersStepsService.findLastRecord(id);

      if (userStep) {
        res
          .status(HttpStatus.OK)
          .send(
            successResponse(
              200,
              lan('common.data_retrieved_successfully'),
              userStep,
            ),
          );
      }
    } catch (error) {
      if (
        error instanceof NotFoundException ||
        error instanceof BadRequestException
      ) {
        res
          .status(HttpStatus.BAD_REQUEST)
          .send(errorResponse(404, error.message));
      } else {
        res
          .status(HttpStatus.INTERNAL_SERVER_ERROR)
          .send(errorResponse(500, lan('common.internal_server_error'), error));
      }

      saveError(error, this.apiLogRepository);
    }
  }

  @Get(':id/steps-history')
  @UseGuards(AuthMiddleware)
  async findHighestStepsWithDate(
    @Param('id') id: string,
    @Res() res: ExpressResponse,
  ) {
    try {
      const userStep = await this.appUsersStepsService.findHighestStepsWithDate(
        id,
      );

      if (userStep) {
        res
          .status(HttpStatus.OK)
          .send(
            successResponse(
              200,
              lan('common.data_retrieved_successfully'),
              userStep,
            ),
          );
      }
    } catch (error) {
      if (
        error instanceof NotFoundException ||
        error instanceof BadRequestException
      ) {
        res
          .status(HttpStatus.BAD_REQUEST)
          .send(errorResponse(404, error.message));
      } else {
        res
          .status(HttpStatus.INTERNAL_SERVER_ERROR)
          .send(errorResponse(500, lan('common.internal_server_error'), error));
      }

      saveError(error, this.apiLogRepository);
    }
  }

  @Get(':id/user')
  @UseGuards(AuthMiddleware)
  async findByUser(@Param('id') id: string, @Res() res: ExpressResponse) {
    try {
      const userStep = await this.appUsersStepsService.findUserById(id);

      if (userStep) {
        res
          .status(HttpStatus.OK)
          .send(
            successResponse(
              200,
              lan('common.data_retrieved_successfully'),
              userStep,
            ),
          );
      }
    } catch (error) {
      if (
        error instanceof NotFoundException ||
        error instanceof BadRequestException
      ) {
        res
          .status(HttpStatus.BAD_REQUEST)
          .send(errorResponse(404, error.message));
      } else {
        res
          .status(HttpStatus.INTERNAL_SERVER_ERROR)
          .send(errorResponse(500, lan('common.internal_server_error'), error));
      }

      saveError(error, this.apiLogRepository);
    }
  }
}