import { Injectable } from '@nestjs/common';
import { UserActivity } from '../domain/user-activity';
import { UserActivityMapper } from '../mappers/user-activity.mapper';
import { Prisma } from '@prisma/client';
import { PrismaService } from '@/database/services/prisma.service';
import { SearchEmailLogDTO, SearchUserActivityDTO } from '@studio-m/app-types';

@Injectable()
export class UserActivityRepo {
  constructor(private prisma: PrismaService) {}

  async create(activity: UserActivity): Promise<UserActivity | null> {
    const toPersistence = UserActivityMapper.toPrisma(activity);
    const created = await this.prisma.userActivity.create({
      data: toPersistence,
    });

    if (!created) {
      return null;
    }

    return UserActivityMapper.toDomain(created);
  }

  async update(activity: UserActivity): Promise<UserActivity | null> {
    const updated = await this.prisma.userActivity.update({
      data: UserActivityMapper.toPrisma(activity),
      where: {
        id: activity.id,
      },
    });

    return UserActivityMapper.toDomain(updated);
  }

  async delete(where: Prisma.UserActivityWhereUniqueInput): Promise<void> {
    await this.prisma.userActivity.delete({
      where,
    });
  }

  async findById(id: string): Promise<UserActivity | null> {
    const activity = await this.prisma.userActivity.findUnique({
      where: {
        id,
      },
    });

    if (!activity) {
      return null;
    }

    return UserActivityMapper.toDomain(activity);
  }

  async search(query: SearchUserActivityDTO): Promise<UserActivity[]> {
    const where: Prisma.UserActivityWhereInput = {};

    if (query.userId) {
      where.userId = query.userId;
    }

    if (query.action?.length) {
      where.action = {
        in: query.action,
      };
    }

    if (query.method) {
      where.method = query.method;
    }

    if (query.entityId) {
      where.entityId = query.entityId;
    }

    if (query.status) {
      where.status = query.status;
    }

    if (query.startDate || query.endDate) {
      where.createdAt = {};
      if (query.startDate) {
        where.createdAt.gte = query.startDate;
      }
      if (query.endDate) {
        where.createdAt.lte = query.endDate;
      }
    }

    const activities = await this.prisma.userActivity.findMany({
      where,
      orderBy: {
        createdAt: 'desc',
      },
    });

    return activities.map((activity) => UserActivityMapper.toDomain(activity));
  }

  async count(query: SearchUserActivityDTO): Promise<number> {
    const where: Prisma.UserActivityWhereInput = {};

    if (query.userId) {
      where.userId = query.userId;
    }

    if (query.action?.length) {
      where.action = {
        in: query.action,
      };
    }

    if (query.method) {
      where.method = query.method;
    }

    if (query.entityId) {
      where.entityId = query.entityId;
    }

    if (query.status) {
      where.status = query.status;
    }

    if (query.startDate || query.endDate) {
      where.createdAt = {};
      if (query.startDate) {
        where.createdAt.gte = query.startDate;
      }
      if (query.endDate) {
        where.createdAt.lte = query.endDate;
      }
    }

    return this.prisma.userActivity.count({
      where,
    });
  }

  async findByTypeAndIp(
    action: string,
    ip: string,
  ): Promise<UserActivity | null> {
    const activity = await this.prisma.userActivity.findFirst({
      where: {
        AND: [
          {
            action,
          },
          {
            ipAddress: ip,
          },
        ],
      },
    });

    return activity ? UserActivityMapper.toDomain(activity) : null;
  }

  async findByTypeIpAndEntity(
    action: string,
    ip: string,
    entityId: string,
  ): Promise<UserActivity | null> {
    const activity = await this.prisma.userActivity.findFirst({
      where: {
        AND: [{ action }, { ipAddress: ip }, { entityId }],
      },
    });

    return activity ? UserActivityMapper.toDomain(activity) : null;
  }

  async searchEmailLogs(query: SearchEmailLogDTO): Promise<UserActivity[]> {
    const defaultActions = [
      'SHOOTING_SHARED_BY_EMAIL',
      'CUSTOMER_GALLERY_SHARED_BY_EMAIL',
    ];

    const where: Prisma.UserActivityWhereInput = {
      action: {
        in: query.actions?.length ? query.actions : defaultActions,
      },
    };

    if (query.startDate || query.endDate) {
      where.createdAt = {};
      if (query.startDate) {
        where.createdAt.gte = new Date(query.startDate);
      }
      if (query.endDate) {
        where.createdAt.lte = new Date(query.endDate);
      }
    }

    const andConditions: Prisma.UserActivityWhereInput[] = [];

    if (query.shootingIds?.length) {
      andConditions.push({
        action: 'SHOOTING_SHARED_BY_EMAIL',
        entityId: {
          in: query.shootingIds,
        },
      });
    }

    if (query.customerIds?.length) {
      const customerOr: Prisma.UserActivityWhereInput[] = [
        {
          AND: [
            { action: 'CUSTOMER_GALLERY_SHARED_BY_EMAIL' },
            {
              entityId: {
                in: query.customerIds,
              },
            },
          ],
        },
      ];

      for (const customerId of query.customerIds) {
        customerOr.push({
          AND: [
            { action: 'SHOOTING_SHARED_BY_EMAIL' },
            {
              metadata: {
                string_contains: customerId,
              },
            },
          ],
        });
      }

      andConditions.push({
        OR: customerOr,
      });
    }

    const finalWhere =
      andConditions.length > 0
        ? {
            AND: [where, ...andConditions],
          }
        : where;

    const activities = await this.prisma.userActivity.findMany({
      where: finalWhere,
      orderBy: {
        createdAt: 'desc',
      },
    });

    const shootingIds = Array.from(
      new Set(
        activities
          .filter(
            (activity) =>
              activity.action === 'SHOOTING_SHARED_BY_EMAIL' &&
              activity.entityId,
          )
          .map((activity) => activity.entityId as string),
      ),
    );

    let shootingMap = new Map<
      string,
      {
        id: string;
        name: string;
        customerId?: string | null;
        customer?: Record<string, any> | null;
      }
    >();

    if (shootingIds.length) {
      const shootings = await this.prisma.shooting.findMany({
        where: {
          id: {
            in: shootingIds,
          },
        },
        include: {
          customer: true,
        },
      });

      shootingMap = new Map(
        shootings.map((shooting) => [
          shooting.id,
          {
            id: shooting.id,
            name: shooting.name,
            customerId: shooting.customerId,
            customer: shooting.customer ? { ...shooting.customer } : null,
          },
        ]),
      );
    }

    const customerIds = Array.from(
      new Set(
        activities
          .filter(
            (activity) =>
              activity.action === 'CUSTOMER_GALLERY_SHARED_BY_EMAIL' &&
              activity.entityId,
          )
          .map((activity) => activity.entityId as string),
      ),
    );

    let customerMap = new Map<string, Record<string, any>>();

    if (customerIds.length) {
      const customers = await this.prisma.customer.findMany({
        where: {
          id: {
            in: customerIds,
          },
        },
      });

      customerMap = new Map(
        customers.map((customer) => [
          customer.id,
          { ...customer },
        ]),
      );
    }

    return activities.map((activity) => {
      const domainActivity = UserActivityMapper.toDomain(activity);
      const shooting = activity.entityId
        ? shootingMap.get(activity.entityId)
        : undefined;

      const customer =
        domainActivity.action === 'CUSTOMER_GALLERY_SHARED_BY_EMAIL' &&
        domainActivity.entityId
          ? customerMap.get(domainActivity.entityId)
          : undefined;

      const metadata = {
        ...(domainActivity.metadata ?? {}),
      };

      let hasUpdate = false;

      if (shooting) {
        metadata.shooting = shooting;
        hasUpdate = true;
      }

      if (customer) {
        const existingCustomer =
          metadata.customer && typeof metadata.customer === 'object'
            ? metadata.customer
            : undefined;

        metadata.customer = existingCustomer
          ? {
              ...customer,
              ...existingCustomer,
            }
          : customer;
        hasUpdate = true;
      }

      if (hasUpdate) {
        domainActivity.metadata = metadata;
      }

      return domainActivity;
    });
  }
}
