// src/auth/strategies/local.strategy.ts
import { Injectable, UnauthorizedException } from '@nestjs/common';
import { PassportStrategy } from '@nestjs/passport';
import { Strategy } from 'passport-local';
import { AuthService } from '../auth.service';

@Injectable()
export class LocalStrategy extends PassportStrategy(Strategy) {
  constructor(private authService: AuthService) {
    super({
      usernameField: 'email',  // Замість дефолтного 'username' використовуємо 'email'
      passwordField: 'password', // Дефолтне поле, але явно вказуємо для читабельності
    });
  }

  /**
   * Метод validate() викликається автоматично після витягування credentials
   * 
   * @param email - Email з тіла POST-запиту
   * @param password - Пароль з тіла POST-запиту
   * @returns User entity, яка буде збережена у request.user
   * @throws UnauthorizedException якщо credentials невалідні
   */
  async validate(email: string, password: string) {
    // Делегуємо валідацію сервісному шару
    const user = await this.authService.validateUser(email, password);

    if (!user) {
      // Passport автоматично перетворить це у HTTP 401
      throw new UnauthorizedException('Invalid credentials');
    }

    // Все, що повертається з validate(), потрапляє у request.user
    return {
      userId: user.id,
      email: user.email,
      roles: user.roles,
    };
  }
}

// src/auth/guards/local-auth.guard.ts
import { Injectable } from '@nestjs/common';
import { AuthGuard } from '@nestjs/passport';

@Injectable()
export class LocalAuthGuard extends AuthGuard('local') {}

// src/auth/auth.controller.ts
import { Controller, Post, UseGuards, Request, Body, HttpCode, HttpStatus } from '@nestjs/common';
import { AuthService } from './auth.service';
import { LocalAuthGuard } from './guards/local-auth.guard';
import { LoginDto } from './dto/login.dto';

@Controller('auth')
export class AuthController {
  constructor(private authService: AuthService) {}

  /**
   * POST /auth/login
   * 
   * LocalAuthGuard активує LocalStrategy для валідації email/password
   * Після успішної валідації request.user містить дані з validate()
   */
  @Post('login')
  @UseGuards(LocalAuthGuard)
  @HttpCode(HttpStatus.OK)
  async login(@Request() req, @Body() dto: LoginDto) {
    // На цей момент LocalStrategy вже перевірила credentials
    // і user доступний через req.user

    // Генеруємо JWT токен для автентифікованого користувача
    const { accessToken, tokenType, expiresIn } = await this.authService.generateToken(req.user);

    return {
      statusCode: HttpStatus.OK,
      message: 'Login successful',
      data: {
        accessToken,
        tokenType,
        expiresIn,
        user: req.user,
      },
    };
  }
}

// src/auth/auth.module.ts
import { Module } from '@nestjs/common';
import { PassportModule } from '@nestjs/passport';
import { JwtModule } from '@nestjs/jwt';
import { ConfigModule, ConfigService } from '@nestjs/config';
import { AuthService } from './auth.service';
import { AuthController } from './auth.controller';
import { UsersModule } from '../users/users.module';
import { LocalStrategy } from './strategies/local.strategy';
import { JwtStrategy } from './strategies/jwt.strategy';

@Module({
  imports: [
    UsersModule,
    PassportModule,
    JwtModule.registerAsync({
      imports: [ConfigModule],
      inject: [ConfigService],
      useFactory: (config: ConfigService) => ({
        secret: config.get<string>('JWT_SECRET'),
        signOptions: { expiresIn: '15m' },
      }),
    }),
  ],
  controllers: [AuthController],
  providers: [
    AuthService,
    LocalStrategy,  // Реєстрація LocalStrategy як провайдера
    JwtStrategy,
  ],
  exports: [AuthService],
})
export class AuthModule {}

// src/auth/strategies/jwt.strategy.ts
import { Injectable, UnauthorizedException } from '@nestjs/common';
import { PassportStrategy } from '@nestjs/passport';
import { ExtractJwt, Strategy } from 'passport-jwt';
import { ConfigService } from '@nestjs/config';
import { UsersService } from '../../users/users.service';

@Injectable()
export class JwtStrategy extends PassportStrategy(Strategy) {
  constructor(
    private config: ConfigService,
    private usersService: UsersService, // Опціонально: для завантаження свіжих даних
  ) {
    super({
      // Витягування токена з заголовка "Authorization: Bearer <token>"
      jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
      
      // Чи ігнорувати exp claim (НІКОЛИ не встановлюйте true у продакшні)
      ignoreExpiration: false,
      
      // Секретний ключ для верифікації підпису
      secretOrKey: config.get<string>('JWT_SECRET'),
      
      // Опціонально: перевірка audience та issuer
      // audience: 'my-app-users',
      // issuer: 'my-app',
    });
  }

  /**
   * Метод validate() викликається ПІСЛЯ успішної верифікації токена
   * 
   * @param payload - Декодований payload токена (sub, email, roles, iat, exp)
   * @returns Об'єкт, що буде збережений у request.user
   */
  async validate(payload: any) {
    // Payload вже верифікований — підпис співпадає, exp не минув
    
    // Варіант 1: Мінімальний підхід (використання даних з токена)
    return {
      userId: payload.sub,
      email: payload.email,
      roles: payload.roles,
    };

    // Варіант 2: Завантаження свіжих даних з БД (додаткові запити)
    // const user = await this.usersService.findById(payload.sub);
    // if (!user || !user.isActive) {
    //   throw new UnauthorizedException('User is inactive or deleted');
    // }
    // return {
    //   userId: user.id,
    //   email: user.email,
    //   roles: user.roles,
    // };
  }
}

// З cookie замість заголовка
jwtFromRequest: ExtractJwt.fromExtractors([
  (request) => request?.cookies?.access_token,
]),

// З query parameter (?token=...)
jwtFromRequest: ExtractJwt.fromUrlQueryParameter('token'),

// Комбінація кількох джерел (fallback)
jwtFromRequest: ExtractJwt.fromExtractors([
  ExtractJwt.fromAuthHeaderAsBearerToken(), // Спочатку з заголовка
  ExtractJwt.fromUrlQueryParameter('token'), // Якщо немає — з query
]),

async validate(payload: any) {
  return {
    userId: payload.sub,
    email: payload.email,
    roles: payload.roles,
  };
}

async validate(payload: any) {
  const user = await this.usersService.findById(payload.sub);

  if (!user) {
    throw new UnauthorizedException('User not found');
  }

  if (!user.isActive) {
    throw new UnauthorizedException('User account is disabled');
  }

  return {
    userId: user.id,
    email: user.email,
    roles: user.roles,
    isActive: user.isActive,
  };
}

// src/auth/guards/jwt-auth.guard.ts
import { Injectable, ExecutionContext } from '@nestjs/common';
import { Reflector } from '@nestjs/core';
import { AuthGuard } from '@nestjs/passport';
import { IS_PUBLIC_KEY } from '../decorators/public.decorator';

@Injectable()
export class JwtAuthGuard extends AuthGuard('jwt') {
  constructor(private reflector: Reflector) {
    super();
  }

  /**
   * Перевіряємо, чи маршрут позначений декоратором @Public()
   * Якщо так — пропускаємо автентифікацію
   */
  canActivate(context: ExecutionContext) {
    const isPublic = this.reflector.getAllAndOverride<boolean>(IS_PUBLIC_KEY, [
      context.getHandler(),  // Метод контролера
      context.getClass(),    // Клас контролера
    ]);

    if (isPublic) {
      return true; // Дозволяємо доступ без автентифікації
    }

    // Викликаємо стандартну логіку AuthGuard
    return super.canActivate(context);
  }
}

// src/users/users.controller.ts
import { Controller, Get, UseGuards, Request, Param } from '@nestjs/common';
import { JwtAuthGuard } from '../auth/guards/jwt-auth.guard';
import { UsersService } from './users.service';

@Controller('users')
@UseGuards(JwtAuthGuard) // Захист всього контролера
export class UsersController {
  constructor(private usersService: UsersService) {}

  /**
   * GET /users/profile
   * Отримання профілю поточного користувача
   */
  @Get('profile')
  getProfile(@Request() req) {
    // req.user встановлено JwtStrategy.validate()
    return {
      userId: req.user.userId,
      email: req.user.email,
      roles: req.user.roles,
    };
  }

  /**
   * GET /users/:id
   * Отримання профілю іншого користувача (лише для адмінів)
   */
  @Get(':id')
  async getUserById(@Param('id') id: string, @Request() req) {
    // Перевірка авторизації: чи є користувач адміністратором?
    if (!req.user.roles.includes('admin')) {
      throw new ForbiddenException('Only admins can view other users');
    }

    return this.usersService.findById(id);
  }
}

GET /users/profile HTTP/1.1
Host: localhost:3000
Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiI1NTBlODQwMC1lMjliLTQxZDQtYTcxNi00NDY2NTU0NDAwMDAiLCJlbWFpbCI6Iml2YW5AZXhhbXBsZS5jb20iLCJyb2xlcyI6WyJ1c2VyIl0sImlhdCI6MTY5MzU2NDgwMCwiZXhwIjoxNjkzNTY1NzAwfQ.4Hb3LM-TqHX-2JcGKz9yP3qF8vZ5nR7wQ1xS6mE9kLo

// src/auth/decorators/current-user.decorator.ts
import { createParamDecorator, ExecutionContext } from '@nestjs/common';

/**
 * Декоратор для витягування поточного користувача з request.user
 * 
 * Використання:
 * @Get('profile')
 * getProfile(@CurrentUser() user: UserPayload) {
 *   return user;
 * }
 * 
 * Витягування конкретного поля:
 * @Get('my-posts')
 * getMyPosts(@CurrentUser('userId') userId: string) {
 *   return this.postsService.findByUserId(userId);
 * }
 */
export const CurrentUser = createParamDecorator(
  (data: string | undefined, ctx: ExecutionContext) => {
    const request = ctx.switchToHttp().getRequest();
    const user = request.user;

    // Якщо вказано конкретне поле (наприклад, @CurrentUser('userId'))
    if (data) {
      return user?.[data];
    }

    // Якщо data не вказано — повертаємо весь об'єкт користувача
    return user;
  },
);

// src/posts/posts.controller.ts
import { Controller, Get, Post, Body, UseGuards } from '@nestjs/common';
import { JwtAuthGuard } from '../auth/guards/jwt-auth.guard';
import { CurrentUser } from '../auth/decorators/current-user.decorator';
import { PostsService } from './posts.service';
import { CreatePostDto } from './dto/create-post.dto';

interface UserPayload {
  userId: string;
  email: string;
  roles: string[];
}

@Controller('posts')
@UseGuards(JwtAuthGuard)
export class PostsController {
  constructor(private postsService: PostsService) {}

  /**
   * GET /posts/my
   * Отримання постів поточного користувача
   */
  @Get('my')
  getMyPosts(@CurrentUser() user: UserPayload) {
    // Елегантний доступ до даних користувача без req.user
    return this.postsService.findByUserId(user.userId);
  }

  /**
   * POST /posts
   * Створення нового посту від імені поточного користувача
   */
  @Post()
  createPost(
    @CurrentUser('userId') userId: string, // Витягуємо лише userId
    @Body() dto: CreatePostDto,
  ) {
    return this.postsService.create({
      ...dto,
      authorId: userId, // Автор завжди поточний користувач
    });
  }

  /**
   * GET /posts/stats
   * Статистика з доступом до всього об'єкта користувача
   */
  @Get('stats')
  getStats(@CurrentUser() user: UserPayload) {
    return {
      totalPosts: 42,
      userId: user.userId,
      userEmail: user.email,
      userRoles: user.roles,
    };
  }
}

// src/auth/decorators/public.decorator.ts
import { SetMetadata } from '@nestjs/common';

export const IS_PUBLIC_KEY = 'isPublic';

/**
 * Декоратор для позначення публічних маршрутів, що не вимагають автентифікації
 * 
 * Використання:
 * @Public()
 * @Get('health')
 * healthCheck() {
 *   return { status: 'ok' };
 * }
 */
export const Public = () => SetMetadata(IS_PUBLIC_KEY, true);

// src/auth/guards/jwt-auth.guard.ts
import { Injectable, ExecutionContext } from '@nestjs/common';
import { Reflector } from '@nestjs/core';
import { AuthGuard } from '@nestjs/passport';
import { IS_PUBLIC_KEY } from '../decorators/public.decorator';

@Injectable()
export class JwtAuthGuard extends AuthGuard('jwt') {
  constructor(private reflector: Reflector) {
    super();
  }

  canActivate(context: ExecutionContext) {
    // Читаємо метадані з декоратора @Public()
    const isPublic = this.reflector.getAllAndOverride<boolean>(IS_PUBLIC_KEY, [
      context.getHandler(),  // Перевіряємо метод контролера
      context.getClass(),    // Перевіряємо клас контролера
    ]);

    if (isPublic) {
      return true; // Пропускаємо автентифікацію для публічних маршрутів
    }

    // Для решти маршрутів виконуємо стандартну автентифікацію
    return super.canActivate(context);
  }
}

// src/app.module.ts
import { Module } from '@nestjs/common';
import { APP_GUARD } from '@nestjs/core';
import { JwtAuthGuard } from './auth/guards/jwt-auth.guard';
import { AuthModule } from './auth/auth.module';
import { UsersModule } from './users/users.module';

@Module({
  imports: [AuthModule, UsersModule],
  providers: [
    {
      provide: APP_GUARD,
      useClass: JwtAuthGuard, // Застосовується до ВСІХ маршрутів
    },
  ],
})
export class AppModule {}

// src/auth/auth.controller.ts
import { Controller, Post, Body, HttpCode, HttpStatus } from '@nestjs/common';
import { Public } from './decorators/public.decorator';
import { AuthService } from './auth.service';
import { RegisterDto, LoginDto } from './dto';

@Controller('auth')
export class AuthController {
  constructor(private authService: AuthService) {}

  /**
   * Публічний ендпоінт — реєстрація доступна без токена
   */
  @Public()
  @Post('register')
  async register(@Body() dto: RegisterDto) {
    return this.authService.register(dto.email, dto.password);
  }

  /**
   * Публічний ендпоінт — вхід доступний без токена
   */
  @Public()
  @Post('login')
  @HttpCode(HttpStatus.OK)
  async login(@Body() dto: LoginDto) {
    return this.authService.login(dto.email, dto.password);
  }
}

// src/health/health.controller.ts
import { Controller, Get } from '@nestjs/common';
import { Public } from '../auth/decorators/public.decorator';

@Controller()
export class HealthController {
  /**
   * Публічний health check для моніторингу
   */
  @Public()
  @Get('health')
  healthCheck() {
    return {
      status: 'ok',
      timestamp: new Date().toISOString(),
    };
  }
}

// src/auth/decorators/roles.decorator.ts
import { SetMetadata } from '@nestjs/common';

export const ROLES_KEY = 'roles';

/**
 * Декоратор для визначення ролей, необхідних для доступу до маршруту
 * 
 * Використання:
 * @Roles('admin')
 * @Delete(':id')
 * deleteUser(@Param('id') id: string) { ... }
 * 
 * Кілька ролей (достатньо мати хоча б одну):
 * @Roles('admin', 'moderator')
 */
export const Roles = (...roles: string[]) => SetMetadata(ROLES_KEY, roles);

// src/auth/guards/roles.guard.ts
import { Injectable, CanActivate, ExecutionContext, ForbiddenException } from '@nestjs/common';
import { Reflector } from '@nestjs/core';
import { ROLES_KEY } from '../decorators/roles.decorator';

@Injectable()
export class RolesGuard implements CanActivate {
  constructor(private reflector: Reflector) {}

  canActivate(context: ExecutionContext): boolean {
    // Читаємо ролі з метаданих декоратора @Roles()
    const requiredRoles = this.reflector.getAllAndOverride<string[]>(ROLES_KEY, [
      context.getHandler(),
      context.getClass(),
    ]);

    // Якщо ролі не вказані — дозволяємо доступ
    if (!requiredRoles || requiredRoles.length === 0) {
      return true;
    }

    // Витягуємо дані користувача з request.user (встановлені JwtStrategy)
    const request = context.switchToHttp().getRequest();
    const user = request.user;

    if (!user) {
      throw new ForbiddenException('User not authenticated');
    }

    // Перевіряємо, чи має користувач хоча б одну з необхідних ролей
    const hasRole = requiredRoles.some((role) => user.roles?.includes(role));

    if (!hasRole) {
      throw new ForbiddenException(
        `Access denied. Required roles: [${requiredRoles.join(', ')}]`,
      );
    }

    return true;
  }
}

// src/users/users.controller.ts
import { Controller, Get, Delete, Param, UseGuards } from '@nestjs/common';
import { JwtAuthGuard } from '../auth/guards/jwt-auth.guard';
import { RolesGuard } from '../auth/guards/roles.guard';
import { Roles } from '../auth/decorators/roles.decorator';
import { CurrentUser } from '../auth/decorators/current-user.decorator';
import { UsersService } from './users.service';

@Controller('users')
@UseGuards(JwtAuthGuard, RolesGuard) // Спочатку автентифікація, потім авторизація
export class UsersController {
  constructor(private usersService: UsersService) {}

  /**
   * GET /users/profile
   * Доступно всім автентифікованим користувачам
   */
  @Get('profile')
  getProfile(@CurrentUser() user) {
    return user;
  }

  /**
   * GET /users
   * Доступно лише адміністраторам
   */
  @Get()
  @Roles('admin')
  getAllUsers() {
    return this.usersService.findAll();
  }

  /**
   * DELETE /users/:id
   * Доступно адміністраторам та модераторам
   */
  @Delete(':id')
  @Roles('admin', 'moderator')
  deleteUser(@Param('id') id: string) {
    return this.usersService.delete(id);
  }
}

@UseGuards(JwtAuthGuard, RolesGuard)

// src/auth/auth.controller.spec.ts
import { Test, TestingModule } from '@nestjs/testing';
import { INestApplication, ValidationPipe } from '@nestjs/common';
import * as request from 'supertest';
import { AppModule } from '../app.module';
import { UsersService } from '../users/users.service';

describe('Authentication E2E Tests', () => {
  let app: INestApplication;
  let usersService: UsersService;

  beforeAll(async () => {
    const moduleFixture: TestingModule = await Test.createTestingModule({
      imports: [AppModule],
    }).compile();

    app = moduleFixture.createNestApplication();
    app.useGlobalPipes(new ValidationPipe({ whitelist: true }));
    await app.init();

    usersService = moduleFixture.get<UsersService>(UsersService);
  });

  afterAll(async () => {
    await app.close();
  });

  describe('POST /auth/register', () => {
    it('should register a new user', async () => {
      const response = await request(app.getHttpServer())
        .post('/auth/register')
        .send({
          email: 'test@example.com',
          password: 'SecureP@ss123',
        })
        .expect(201);

      expect(response.body).toMatchObject({
        statusCode: 201,
        message: 'User registered successfully',
        data: {
          email: 'test@example.com',
        },
      });
      expect(response.body.data.id).toBeDefined();
    });

    it('should reject duplicate email', async () => {
      await request(app.getHttpServer())
        .post('/auth/register')
        .send({
          email: 'duplicate@example.com',
          password: 'SecureP@ss123',
        })
        .expect(201);

      const response = await request(app.getHttpServer())
        .post('/auth/register')
        .send({
          email: 'duplicate@example.com',
          password: 'AnotherP@ss123',
        })
        .expect(409);

      expect(response.body.message).toContain('already exists');
    });

    it('should reject weak password', async () => {
      const response = await request(app.getHttpServer())
        .post('/auth/register')
        .send({
          email: 'weak@example.com',
          password: 'weak',
        })
        .expect(400);

      expect(response.body.message).toContain('at least 8 characters');
    });
  });

  describe('POST /auth/login', () => {
    beforeEach(async () => {
      await request(app.getHttpServer())
        .post('/auth/register')
        .send({
          email: 'login-test@example.com',
          password: 'SecureP@ss123',
        });
    });

    it('should login with valid credentials', async () => {
      const response = await request(app.getHttpServer())
        .post('/auth/login')
        .send({
          email: 'login-test@example.com',
          password: 'SecureP@ss123',
        })
        .expect(200);

      expect(response.body.data).toHaveProperty('accessToken');
      expect(response.body.data.tokenType).toBe('Bearer');
      expect(response.body.data.user.email).toBe('login-test@example.com');
    });

    it('should reject invalid password', async () => {
      const response = await request(app.getHttpServer())
        .post('/auth/login')
        .send({
          email: 'login-test@example.com',
          password: 'WrongPassword123',
        })
        .expect(401);

      expect(response.body.message).toContain('Invalid credentials');
    });

    it('should reject non-existent email', async () => {
      const response = await request(app.getHttpServer())
        .post('/auth/login')
        .send({
          email: 'nonexistent@example.com',
          password: 'SecureP@ss123',
        })
        .expect(401);

      expect(response.body.message).toContain('Invalid credentials');
    });
  });

  describe('GET /users/profile (Protected Route)', () => {
    let accessToken: string;

    beforeEach(async () => {
      await request(app.getHttpServer())
        .post('/auth/register')
        .send({
          email: 'profile-test@example.com',
          password: 'SecureP@ss123',
        });

      const loginResponse = await request(app.getHttpServer())
        .post('/auth/login')
        .send({
          email: 'profile-test@example.com',
          password: 'SecureP@ss123',
        });

      accessToken = loginResponse.body.data.accessToken;
    });

    it('should access protected route with valid token', async () => {
      const response = await request(app.getHttpServer())
        .get('/users/profile')
        .set('Authorization', `Bearer ${accessToken}`)
        .expect(200);

      expect(response.body.data.email).toBe('profile-test@example.com');
    });

    it('should reject request without token', async () => {
      await request(app.getHttpServer())
        .get('/users/profile')
        .expect(401);
    });

    it('should reject request with invalid token', async () => {
      await request(app.getHttpServer())
        .get('/users/profile')
        .set('Authorization', 'Bearer invalid-token-here')
        .expect(401);
    });

    it('should reject request with expired token', async () => {
      // Токен з exp у минулому (згенерований окремо)
      const expiredToken = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJ1c2VyMTIzIiwiZXhwIjoxNjAwMDAwMDAwfQ.signature';

      await request(app.getHttpServer())
        .get('/users/profile')
        .set('Authorization', `Bearer ${expiredToken}`)
        .expect(401);
    });
  });
});