dispute.service.ts

import {
  ConflictException,
  Injectable,
  NotFoundException,
} from '@nestjs/common';
import {
  DisputeRecord,
  DisputeState,
  EscrowRecord,
  PrismaService,
  toDisputeRecord,
} from '../../prisma/prisma.service';
import { EscrowRepository } from '../../escrow/escrow.repository';
import { ContractService } from '../../stellar/contract.service';

@Injectable()
export class DisputeService {
  constructor(
    private readonly escrowRepository: EscrowRepository,
    private readonly contractService: ContractService,
    private readonly prisma: PrismaService,
  ) {}

  async getDisputes(query: {
    status?: string;
    page?: number;
    limit?: number;
  }): Promise<{
    data: DisputeRecord[];
    total: number;
    page: number;
    limit: number;
  }> {
    const page = Math.max(1, query.page ?? 1);
    const limit = Math.min(100, Math.max(1, query.limit ?? 20));
    const skip = (page - 1) * limit;

    const where = query.status
      ? { status: query.status as DisputeState }
      : undefined;

    const [data, total] = await Promise.all([
      this.prisma.dispute.findMany({
        where,
        orderBy: { createdAt: 'desc' },
        skip,
        take: limit,
      }),
      this.prisma.dispute.count({ where }),
    ]);
    return { data: data.map(toDisputeRecord), total, page, limit };
  }

  /** Resolves a dispute by submitting the contract action and finalizing escrow state. */
  async resolve(
    escrowId: string,
    resolution: 'RELEASE' | 'REFUND',
  ): Promise<EscrowRecord> {
    const escrow = await this.escrowRepository.findById(escrowId);
    if (!escrow) {
      throw new NotFoundException('Escrow not found');
    }

    if (escrow.state === 'COMPLETED' || escrow.state === 'REFUNDED') {
      throw new ConflictException('Dispute has already been resolved');
    }

    await this.contractService.resolveDispute(escrowId, resolution);

    const dispute = await this.prisma.dispute.findFirst({
      where: { escrowId, status: 'OPEN' },
    });
    if (dispute) {
      await this.prisma.dispute.update({
        where: { id: dispute.id },
        data: { status: 'RESOLVED', resolvedAt: new Date() },
      });
    }

    if (resolution === 'RELEASE') {
      return this.escrowRepository.markCompleted(escrowId);
    }
    return this.escrowRepository.markRefunded(escrowId);
  }
}