import { Dispute, DisputeEvent } from './dispute-flow.model';
import { db } from '../db';

export class DisputeFlowService {
  async createDispute(disputeData: Partial<Dispute>): Promise<Dispute> {
    const query = `
      INSERT INTO disputes 
        (deal_id, opened_by_user_id, status, reason_code, summary, requested_outcome)
      VALUES (?, ?, ?, ?, ?, ?)
      RETURNING *
    `;
    
    const values = [
      disputeData.dealId,
      disputeData.openedByUserId,
      disputeData.status || 'open',
      disputeData.reasonCode,
      disputeData.summary,
      disputeData.requestedOutcome
    ];
    
    const result = await db.query(query, values);
    return result.rows[0];
  }

  async addEvidence(disputeId: number, evidenceData: any, actorUserId: number): Promise<void> {
    // Insert evidence as a new event
    const query = `
      INSERT INTO dispute_events 
        (dispute_id, event_type, actor_user_id, payload_json)
      VALUES (?, ?, ?, ?)
    `;
    
    const values = [
      disputeId,
      'evidence',
      actorUserId,
      JSON.stringify(evidenceData)
    ];
    
    await db.query(query, values);
  }

  async updateDisputeStatus(disputeId: number, newStatus: string, actorUserId: number): Promise<void> {
    // Update the dispute status
    const query = `
      UPDATE disputes 
      SET status = ? 
      WHERE id = ?
    `;
    
    await db.query(query, [newStatus, disputeId]);
    
    // Log the status change as an event
    const eventQuery = `
      INSERT INTO dispute_events 
        (dispute_id, event_type, actor_user_id, payload_json)
      VALUES (?, ?, ?, ?)
    `;
    
    const values = [
      disputeId,
      'status_change',
      actorUserId,
      JSON.stringify({ newStatus })
    ];
    
    await db.query(eventQuery, values);
  }

  async resolveDispute(disputeId: number, decisionData: any, actorUserId: number): Promise<void> {
    // Update the dispute with final decision
    const query = `
      UPDATE disputes 
      SET status = 'resolved',
          final_decision = ?,
          final_reason = ?,
          decided_by_user_id = ?,
          decided_at = NOW()
      WHERE id = ?
    `;
    
    await db.query(query, [
      decisionData.decision,
      decisionData.decisionReason,
      actorUserId,
      disputeId
    ]);
    
    // Log the resolution as an event
    const eventQuery = `
      INSERT INTO dispute_events 
        (dispute_id, event_type, actor_user_id, payload_json)
      VALUES (?, ?, ?, ?)
    `;
    
    const values = [
      disputeId,
      'resolved',
      actorUserId,
      JSON.stringify(decisionData)
    ];
    
    await db.query(eventQuery, values);
  }

  async getDisputeById(disputeId: number): Promise<Dispute | null> {
    const query = 'SELECT * FROM disputes WHERE id = ?';
    const result = await db.query(query, [disputeId]);
    return result.rows[0] || null;
  }

  async getDisputeEvents(disputeId: number): Promise<DisputeEvent[]> {
    const query = 'SELECT * FROM dispute_events WHERE dispute_id = ? ORDER BY created_at ASC';
    const result = await db.query(query, [disputeId]);
    return result.rows;
  }
}