import type {Liability, Prisma} from '@prisma/client';
import {DatabaseConnection} from '../config/database';

const prisma = DatabaseConnection.getInstance();

/**
 * Repository for Liability data access
 * Implements Single Responsibility Principle - handles only database operations
 */
export class LiabilityRepository {
  async findById(id: string): Promise<Liability | null> {
    return prisma.liability.findUnique({
      where: {id}
    });
  }

  async findByIdAndUser(id: string, userId: string): Promise<Liability | null> {
    return prisma.liability.findFirst({
      where: {id, userId}
    });
  }

  async findAllByUser(userId: string): Promise<Liability[]> {
    return prisma.liability.findMany({
      where: {userId},
      orderBy: {createdAt: 'desc'}
    });
  }

  async create(data: Prisma.LiabilityCreateInput): Promise<Liability> {
    return prisma.liability.create({
      data
    });
  }

  async update(id: string, data: Prisma.LiabilityUpdateInput): Promise<Liability> {
    return prisma.liability.update({
      where: {id},
      data
    });
  }

  async delete(id: string): Promise<void> {
    await prisma.liability.delete({
      where: {id}
    });
  }

  /**
   * Get total value of all liabilities for a user
   */
  async getTotalValue(userId: string): Promise<number> {
    const result = await prisma.liability.aggregate({
      where: {userId},
      _sum: {
        balance: true
      }
    });

    return result._sum.balance || 0;
  }

  /**
   * Get liabilities grouped by type
   */
  async getByType(userId: string): Promise<Record<string, Liability[]>> {
    const liabilities = await this.findAllByUser(userId);

    return liabilities.reduce(
      (acc, liability) => {
        const type = liability.type;
        if (!acc[type]) {
          acc[type] = [];
        }
        acc[type].push(liability);
        return acc;
      },
      {} as Record<string, Liability[]>
    );
  }
}