import {
  Injectable,
  NestInterceptor,
  ExecutionContext,
  CallHandler,
} from '@nestjs/common';
import { Observable, tap } from 'rxjs';
import { UserActivity } from '../domain/user-activity';
import { Request, Response } from 'express';
import { UserActivityRepo } from '../repos/user-activity.repo';
import { Reflector } from '@nestjs/core';
import { ACTIVITY_ACTION_KEY } from '../decorators/track-activity';
import { ENTITY_ID_PARAM_KEY } from '../decorators/entity-id-param';

@Injectable()
export class UserActivityInterceptor implements NestInterceptor {
  constructor(
    private userActivityRepo: UserActivityRepo,
    private reflector: Reflector,
  ) {}

  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
    const request = context.switchToHttp().getRequest<Request>();
    const response = context.switchToHttp().getResponse<Response>();
    const startTime = Date.now();

    const action = this.reflector.get<string>(
      ACTIVITY_ACTION_KEY,
      context.getHandler(),
    );

    const entityIdParam = this.reflector.get<string>(
      ENTITY_ID_PARAM_KEY,
      context.getHandler(),
    );

    return next.handle().pipe(
      tap({
        next: async (data) => {
          const currentUser = request['currentUser'];

          if (currentUser) {
            return;
          }

          let entityId = request.body?.entityId || data?.id;

          if (
            entityIdParam &&
            request.params &&
            request.params[entityIdParam]
          ) {
            entityId = request.params[entityIdParam];
          }

          const resolvedAction = request.body?.action || action;
          if (request.ip && resolvedAction === 'SHOOTING_VIEW' && entityId) {
            const activity =
              await this.userActivityRepo.findByTypeIpAndEntity(
                'SHOOTING_VIEW',
                request.ip,
                entityId,
              );

            if (activity) {
              return;
            }
          }

          const activity = UserActivity.create({
            userId: currentUser?.id,
            action: request.body?.action || action || request.method,
            endpoint: request.originalUrl,
            method: request.method,
            ipAddress: request.ip,
            userAgent: request.headers['user-agent'],
            status: response.statusCode,
            entityId,
            metadata: {
              body: request.body,
              params: request.params,
              query: request.query,
              duration: Date.now() - startTime,
            },
            createdAt: new Date(),
          });

          await this.userActivityRepo.create(activity);
        },
        error: async (error) => {
          const currentUser = request['currentUser'];
          if (currentUser) {
            return;
          }

          let entityId = request.params?.id;
          if (
            entityIdParam &&
            request.params &&
            request.params[entityIdParam]
          ) {
            entityId = request.params[entityIdParam];
          }

          const activity = UserActivity.create({
            userId: currentUser?.id,
            action: request.body?.activity || action || request.method,
            endpoint: request.originalUrl,
            method: request.method,
            ipAddress: request.ip,
            userAgent: request.headers['user-agent'],
            status: error.status || 500,
            entityId,
            metadata: {
              body: request.body,
              params: request.params,
              query: request.query,
              error: {
                message: error.message,
                stack: error.stack,
              },
              duration: Date.now() - startTime,
            },
            createdAt: new Date(),
          });

          await this.userActivityRepo.create(activity);
        },
      }),
    );
  }
}
