import {
  Controller,
  Get,
  Post,
  Put,
  Delete,
  Param,
  Body,
  UseGuards,
  ParseIntPipe,
  Query,
} from '@nestjs/common';
import { JwtAuthGuard } from '../auth/guards/jwt-auth.guard';
import { Permissions } from '../auth/permissions.decorator';
import { PermissionsGuard } from '../auth/guards/permissions.guard';
import { CurrentUser, AuthenticatedUser } from '../common/decorators/current-user.decorator';
import { ReorderDto } from '../common/dto/reorder.dto';
import { ModulesService } from './modules.service';
import { CreateModuleDto } from './dto/create-module.dto';
import { UpdateModuleDto } from './dto/update-module.dto';
import { ModuleVersionsService } from '../module-versions/module-versions.service';
import { ChangeReasonDto } from '../module-versions/module-versions.controller';

@Controller('api/v1/admin/modules')
@UseGuards(JwtAuthGuard, PermissionsGuard)
export class ModulesController {
  constructor(
    private readonly modulesService: ModulesService,
    private readonly versionsService: ModuleVersionsService,
  ) {}

  @Post()
  @Permissions('module.create')
  async create(@Body() dto: CreateModuleDto) {
    const module = await this.modulesService.create(dto);
    return { success: true, message: 'Module created', data: module };
  }

  @Get()
  @Permissions('module.view')
  async findAll(
    @Query('sectionId') sectionId?: string,
    @Query('status') status?: string,
    @Query('search') search?: string,
  ) {
    const modules = await this.modulesService.findAll({
      sectionId: sectionId ? Number(sectionId) : undefined,
      status,
      search,
    });
    return { success: true, message: 'Success', data: modules };
  }

  @Get(':id')
  @Permissions('module.view')
  async findById(@Param('id', ParseIntPipe) id: number) {
    const module = await this.modulesService.findById(id);
    if (!module) return { success: false, message: 'Module not found' };
    return { success: true, message: 'Success', data: module };
  }

  @Put(':id')
  @Permissions('module.update')
  async update(@Param('id', ParseIntPipe) id: number, @Body() dto: UpdateModuleDto) {
    const module = await this.modulesService.update(id, dto);
    if (!module) return { success: false, message: 'Module not found' };
    return { success: true, message: 'Module updated', data: module };
  }

  @Post('reorder')
  @Permissions('module.update')
  async reorder(@Body() dto: ReorderDto) {
    await this.modulesService.reorder(dto.items);
    return { success: true, message: 'Modules reordered' };
  }

  @Delete(':id')
  @Permissions('module.delete')
  async delete(@Param('id', ParseIntPipe) id: number) {
    const success = await this.modulesService.delete(id);
    return { success, message: success ? 'Module deleted' : 'Module not found' };
  }

  // ---------------------------------------------------------------------------
  // Publishing workflow: draft -> in review -> published (section 9 and 10)
  // ---------------------------------------------------------------------------

  @Post(':id/submit-review')
  @Permissions('module.update')
  async submitForReview(
    @Param('id', ParseIntPipe) id: number,
    @CurrentUser() user: AuthenticatedUser,
  ) {
    const result = await this.versionsService.setStatus(id, 'IN_REVIEW', user.id);
    return { success: true, message: 'Module submitted for review', data: result.module };
  }

  @Post(':id/publish')
  @Permissions('module.publish')
  async publish(
    @Param('id', ParseIntPipe) id: number,
    @Body() dto: ChangeReasonDto,
    @CurrentUser() user: AuthenticatedUser,
  ) {
    const result = await this.versionsService.publish(id, user.id, dto?.changeReason);
    return {
      success: true,
      message: `Module published as version ${result.version.versionNumber}`,
      data: result.module,
      meta: { versionId: result.version.id, versionNumber: result.version.versionNumber },
    };
  }

  @Post(':id/unpublish')
  @Permissions('module.publish')
  async unpublish(
    @Param('id', ParseIntPipe) id: number,
    @CurrentUser() user: AuthenticatedUser,
  ) {
    const result = await this.versionsService.setStatus(id, 'DRAFT', user.id);
    return { success: true, message: 'Module moved back to draft', data: result.module };
  }

  @Post(':id/archive')
  @Permissions('module.publish')
  async archive(
    @Param('id', ParseIntPipe) id: number,
    @CurrentUser() user: AuthenticatedUser,
  ) {
    const result = await this.versionsService.setStatus(id, 'ARCHIVED', user.id);
    return { success: true, message: 'Module archived', data: result.module };
  }
}