import { Body, Controller, Get, Post, Req, UnauthorizedException, BadRequestException, UseGuards } from '@nestjs/common';
import { LoginDto } from './dto/login.dto';
import { AuthService } from './auth.service';
import { Public } from 'src/common/decorators/public.decorator';
import { RegisterDto } from './dto/register.dto';
import { RegisterParentCompletDto } from './dto/register-parent-complet.dto';
import { RegisterAMCompletDto } from './dto/register-am-complet.dto';
import { ChangePasswordRequiredDto } from './dto/change-password.dto';
import { ApiBearerAuth, ApiOperation, ApiResponse, ApiTags } from '@nestjs/swagger';
import { AuthGuard } from 'src/common/guards/auth.guard';
import type { Request } from 'express';
import { UserService } from '../user/user.service';
import { ProfileResponseDto } from './dto/profile_response.dto';
import { RefreshTokenDto } from './dto/refresh_token.dto';
import { User } from 'src/common/decorators/user.decorator';
import { Users } from 'src/entities/users.entity';

@ApiTags('Authentification')
@Controller('auth')
export class AuthController {
    constructor(
        private readonly authService: AuthService,
        private readonly userService: UserService,
    ) { }


    @Public()
    @ApiOperation({ summary: 'Connexion' })
    @Post('login')
    async login(@Body() dto: LoginDto) {
        return this.authService.login(dto);
    }

    @Public()
    @Post('register')
    @ApiOperation({ summary: 'Inscription (OBSOLÈTE - utiliser /register/parent)' })
    @ApiResponse({ status: 409, description: 'Email déjà utilisé' })
    async register(@Body() dto: RegisterDto) {
        return this.authService.register(dto);
    }

    @Public()
    @Post('register/parent')
    @ApiOperation({ 
        summary: 'Inscription Parent COMPLÈTE - Workflow 6 étapes',
        description: 'Crée Parent 1 + Parent 2 (opt) + Enfants + Présentation + CGU en une transaction'
    })
    @ApiResponse({ status: 201, description: 'Inscription réussie - Dossier en attente de validation' })
    @ApiResponse({ status: 400, description: 'Données invalides ou CGU non acceptées' })
    @ApiResponse({ status: 409, description: 'Email déjà utilisé' })
    async inscrireParentComplet(@Body() dto: RegisterParentCompletDto) {
        return this.authService.inscrireParentComplet(dto);
    }

    @Public()
    @Post('register/am')
    @ApiOperation({
        summary: 'Inscription Assistante Maternelle COMPLÈTE',
        description: 'Crée User AM + entrée assistantes_maternelles (identité + infos pro + photo + CGU) en une transaction',
    })
    @ApiResponse({ status: 201, description: 'Inscription réussie - Dossier en attente de validation' })
    @ApiResponse({ status: 400, description: 'Données invalides ou CGU non acceptées' })
    @ApiResponse({ status: 409, description: 'Email déjà utilisé' })
    async inscrireAMComplet(@Body() dto: RegisterAMCompletDto) {
        return this.authService.inscrireAMComplet(dto);
    }

    @Public()
    @Post('refresh')
    @ApiBearerAuth('refresh_token')
    @ApiResponse({ status: 200, description: 'Nouveaux tokens générés avec succès.' })
    @ApiResponse({ status: 401, description: 'Token de rafraîchissement invalide ou expiré.' })
    @ApiOperation({ summary: 'Rafraichir les tokens' })
    async refresh(@Body() dto: RefreshTokenDto) {
        return this.authService.refreshTokens(dto.refresh_token);
    }

    @Get('me')
    @UseGuards(AuthGuard)
    @ApiBearerAuth('access-token')
    @ApiOperation({ summary: "Récupérer le profil complet de l'utilisateur connecté" })
    @ApiResponse({ status: 200, type: ProfileResponseDto })
    async getProfile(@Req() req: Request): Promise<ProfileResponseDto> {
        if (!req.user || !req.user.sub) {
            throw new UnauthorizedException('Utilisateur non authentifié');
        }
        const user = await this.userService.findOne(req.user.sub);
        return {
            id: user.id,
            email: user.email,
            role: user.role,
            prenom: user.prenom ?? '',
            nom: user.nom ?? '',
            statut: user.statut,
            changement_mdp_obligatoire: user.changement_mdp_obligatoire,
        };
    }

    @UseGuards(AuthGuard)
    @ApiBearerAuth('access-token')
    @Post('logout')
    logout(@User() currentUser: Users) {
        return this.authService.logout(currentUser.id);
    }

    @Post('change-password-required')
    @UseGuards(AuthGuard)
    @ApiBearerAuth('access-token')
    @ApiOperation({ 
        summary: 'Changement de mot de passe obligatoire',
        description: 'Permet de changer le mot de passe lors de la première connexion (flag changement_mdp_obligatoire)'
    })
    @ApiResponse({ status: 200, description: 'Mot de passe changé avec succès' })
    @ApiResponse({ status: 400, description: 'Mot de passe actuel incorrect ou confirmation non correspondante' })
    @ApiResponse({ status: 403, description: 'Changement de mot de passe non requis pour cet utilisateur' })
    async changePasswordRequired(
        @User() currentUser: Users,
        @Body() dto: ChangePasswordRequiredDto,
    ) {
        // Vérifier que les mots de passe correspondent
        if (dto.nouveau_mot_de_passe !== dto.confirmation_mot_de_passe) {
            throw new BadRequestException('Les mots de passe ne correspondent pas');
        }

        return this.authService.changePasswordRequired(
            currentUser.id,
            dto.mot_de_passe_actuel,
            dto.nouveau_mot_de_passe,
        );
    }
}

