import pool from '../config/database';
import logger from '../utils/logger';

async function getIssues(userId: string, canViewAll: boolean) {
  try {
    const query = `
      SELECT i.*,
             u1.name AS erstellt_von_name,
             u2.name AS zugewiesen_an_name
      FROM issues i
      LEFT JOIN users u1 ON u1.id = i.erstellt_von
      LEFT JOIN users u2 ON u2.id = i.zugewiesen_an
      ${canViewAll ? '' : 'WHERE i.erstellt_von = $1'}
      ORDER BY i.created_at DESC
    `;
    const result = canViewAll
      ? await pool.query(query)
      : await pool.query(query, [userId]);
    return result.rows;
  } catch (error) {
    logger.error('IssueService.getIssues failed', { error });
    throw new Error('Issues konnten nicht geladen werden');
  }
}

async function getIssueById(id: number) {
  try {
    const result = await pool.query(
      `SELECT i.*,
              u1.name AS erstellt_von_name,
              u2.name AS zugewiesen_an_name
       FROM issues i
       LEFT JOIN users u1 ON u1.id = i.erstellt_von
       LEFT JOIN users u2 ON u2.id = i.zugewiesen_an
       WHERE i.id = $1`,
      [id]
    );
    return result.rows[0] || null;
  } catch (error) {
    logger.error('IssueService.getIssueById failed', { error, id });
    throw new Error('Issue konnte nicht geladen werden');
  }
}

async function createIssue(
  data: { titel: string; beschreibung?: string; typ?: string; prioritaet?: string },
  userId: string
) {
  try {
    const result = await pool.query(
      `INSERT INTO issues (titel, beschreibung, typ, prioritaet, erstellt_von)
       VALUES ($1, $2, $3, $4, $5)
       RETURNING *`,
      [
        data.titel,
        data.beschreibung || null,
        data.typ || 'sonstiges',
        data.prioritaet || 'mittel',
        userId,
      ]
    );
    return result.rows[0];
  } catch (error) {
    logger.error('IssueService.createIssue failed', { error });
    throw new Error('Issue konnte nicht erstellt werden');
  }
}

async function updateIssue(
  id: number,
  data: {
    titel?: string;
    beschreibung?: string;
    typ?: string;
    prioritaet?: string;
    status?: string;
    zugewiesen_an?: string | null;
  }
) {
  try {
    const result = await pool.query(
      `UPDATE issues
       SET titel = COALESCE($1, titel),
           beschreibung = COALESCE($2, beschreibung),
           typ = COALESCE($3, typ),
           prioritaet = COALESCE($4, prioritaet),
           status = COALESCE($5, status),
           zugewiesen_an = COALESCE($6, zugewiesen_an),
           updated_at = NOW()
       WHERE id = $7
       RETURNING *`,
      [
        data.titel,
        data.beschreibung,
        data.typ,
        data.prioritaet,
        data.status,
        data.zugewiesen_an,
        id,
      ]
    );
    return result.rows[0] || null;
  } catch (error) {
    logger.error('IssueService.updateIssue failed', { error, id });
    throw new Error('Issue konnte nicht aktualisiert werden');
  }
}

async function deleteIssue(id: number) {
  try {
    const result = await pool.query(
      `DELETE FROM issues WHERE id = $1 RETURNING id`,
      [id]
    );
    return result.rows.length > 0;
  } catch (error) {
    logger.error('IssueService.deleteIssue failed', { error, id });
    throw new Error('Issue konnte nicht gelöscht werden');
  }
}

async function getComments(issueId: number) {
  try {
    const result = await pool.query(
      `SELECT c.*, u.name AS autor_name
       FROM issue_kommentare c
       LEFT JOIN users u ON u.id = c.autor_id
       WHERE c.issue_id = $1
       ORDER BY c.created_at ASC`,
      [issueId]
    );
    return result.rows;
  } catch (error) {
    logger.error('IssueService.getComments failed', { error, issueId });
    throw new Error('Kommentare konnten nicht geladen werden');
  }
}

async function addComment(issueId: number, autorId: string, inhalt: string) {
  try {
    const result = await pool.query(
      `INSERT INTO issue_kommentare (issue_id, autor_id, inhalt)
       VALUES ($1, $2, $3)
       RETURNING *`,
      [issueId, autorId, inhalt]
    );
    return result.rows[0];
  } catch (error) {
    logger.error('IssueService.addComment failed', { error, issueId });
    throw new Error('Kommentar konnte nicht erstellt werden');
  }
}

export default {
  getIssues,
  getIssueById,
  createIssue,
  updateIssue,
  deleteIssue,
  getComments,
  addComment,
};