import { Knex } from 'knex';
import { Dispute, DisputeEvent, createDisputeTables } from './dispute-flow.model';

export class DisputeFlowService {
  constructor(private knex: Knex) {}

  async init(): Promise<void> {
    await createDisputeTables(this.knex);
  }

  async createDispute(disputeData: Omit<Dispute, 'id' | 'created_at' | 'updated_at'>): Promise<Dispute> {
    const [dispute] = await this.knex('disputes').insert(disputeData).returning('*');
    
    // Log the creation event
    await this.logDisputeEvent(dispute.id, 'dispute_created', disputeData.opened_by_user_id, {
      ...disputeData,
      disputeId: dispute.id
    });

    return dispute;
  }

  async getDispute(id: number): Promise<Dispute | null> {
    return await this.knex('disputes').where({ id }).first();
  }

  async updateDisputeStatus(disputeId: number, status: Dispute['status'], updatedByUserId: number): Promise<void> {
    const dispute = await this.getDispute(disputeId);
    if (!dispute) {
      throw new Error(`Dispute with id ${disputeId} not found`);
    }

    await this.knex('disputes')
      .where({ id: disputeId })
      .update({ status, updated_at: this.knex.fn.now() });

    // Log the status change event
    await this.logDisputeEvent(disputeId, 'status_changed', updatedByUserId, {
      oldStatus: dispute.status,
      newStatus: status
    });
  }

  async addEvidence(disputeId: number, evidenceData: any, uploadedByUserId: number): Promise<void> {
    const dispute = await this.getDispute(disputeId);
    if (!dispute) {
      throw new Error(`Dispute with id ${disputeId} not found`);
    }

    // Log the evidence upload event
    await this.logDisputeEvent(disputeId, 'evidence_added', uploadedByUserId, {
      ...evidenceData,
      disputeId
    });
  }

  async resolveDispute(disputeId: number, decision: string, reason: string, resolvedByUserId: number): Promise<void> {
    const dispute = await this.getDispute(disputeId);
    if (!dispute) {
      throw new Error(`Dispute with id ${disputeId} not found`);
    }

    await this.knex('disputes')
      .where({ id: disputeId })
      .update({
        status: 'resolved',
        final_decision: decision,
        final_reason: reason,
        decided_by_user_id: resolvedByUserId,
        decided_at: this.knex.fn.now(),
        updated_at: this.knex.fn.now()
      });

    // Log the resolution event
    await this.logDisputeEvent(disputeId, 'dispute_resolved', resolvedByUserId, {
      decision,
      reason,
      disputeId
    });
  }

  async logDisputeEvent(disputeId: number, eventType: string, actorUserId: number, payload: any): Promise<void> {
    await this.knex('dispute_events').insert({
      dispute_id: disputeId,
      event_type: eventType,
      actor_user_id: actorUserId,
      payload_json: payload,
      created_at: this.knex.fn.now()
    });
  }

  async getDisputeEvents(disputeId: number): Promise<DisputeEvent[]> {
    return await this.knex('dispute_events').where({ dispute_id: disputeId }).orderBy('created_at', 'asc');
  }
}