import { Router } from 'express';
import { getDb } from '../database.js';
import PDFDocument from 'pdfkit'; // Import pdfkit
import axios from 'axios'; // Added for Mantis
import { GoogleGenAI } from '@google/genai'; // Added for GenAI
import * as fs from 'fs'; // Added for reading prompt file
import * as path from 'path'; // Added for path manipulation

const router = Router();

const __dirname = new URL('.', import.meta.url).pathname.replace(/\/$/, '');
import { join } from 'path';

// --- Environment Variables (Ensure these are set in your .env file) ---
const {
  MANTIS_API_KEY,
  MANTIS_API_ENDPOINT,
  GOOGLE_API_KEY
} = process.env;

// --- Mantis Summarizer Setup ---
const promptFilePath = join(__dirname, 'prompt.txt'); // Path relative to this file

const ai = GOOGLE_API_KEY ? new GoogleGenAI({ // Check if API key exists
  apiKey: GOOGLE_API_KEY,
}) : null;

const usernameMap = {
  'credmore': 'Cameron Redmore',
  'dgibson': 'Dane Gibson',
  'egzibovskis': 'Ed Gzibovskis',
  'ascotney': 'Amanda Scotney',
  'gclough': 'Garry Clough',
  'slee': 'Sarah Lee',
  'dwalker': 'Dave Walker',
  'askaith': 'Amy Skaith',
  'dpotter': 'Danny Potter',
  'msmart': 'Michael Smart',
  // Add other usernames as needed
};

async function getMantisTickets() {
  if (!MANTIS_API_ENDPOINT || !MANTIS_API_KEY) {
    throw new Error("Mantis API endpoint or key not configured in environment variables.");
  }
  const url = `${MANTIS_API_ENDPOINT}/issues?project_id=1&page_size=50&select=id,summary,description,created_at,updated_at,reporter,notes`;
  const headers = {
    'Authorization': `${MANTIS_API_KEY}`,
    'Accept': 'application/json',
    'Content-Type': 'application/json',
  };

  try {
    const response = await axios.get(url, { headers });

    const tickets = response.data.issues.filter((ticket) => {
      const ticketDate = new Date(ticket.updated_at);
      const thresholdDate = new Date();
      const currentDay = thresholdDate.getDay(); // Sunday = 0, Monday = 1, ...

      // Go back 4 days if Monday (to include Fri, Sat, Sun), otherwise 2 days
      const daysToSubtract = currentDay === 1 ? 4 : 2;
      thresholdDate.setDate(thresholdDate.getDate() - daysToSubtract);
      thresholdDate.setHours(0, 0, 0, 0); // Start of the day

      return ticketDate >= thresholdDate;
    }).map((ticket) => {
      return {
        id: ticket.id,
        summary: ticket.summary,
        description: ticket.description,
        created_at: ticket.created_at,
        updated_at: ticket.updated_at,
        reporter: usernameMap[ticket.reporter?.username] || ticket.reporter?.name || 'Unknown Reporter', // Safer access
        notes: (ticket.notes ? ticket.notes.filter((note) => {
          const noteDate = new Date(note.created_at);
          const thresholdDate = new Date();
          const currentDay = thresholdDate.getDay();
          const daysToSubtract = currentDay === 1 ? 4 : 2;
          thresholdDate.setDate(thresholdDate.getDate() - daysToSubtract);
          thresholdDate.setHours(0, 0, 0, 0); // Start of the day
          return noteDate >= thresholdDate;
        }) : []).map((note) => {
          const reporter = usernameMap[note.reporter?.username] || note.reporter?.name || 'Unknown Reporter'; // Safer access
          return {
            reporter,
            created_at: note.created_at,
            text: note.text,
          };
        }),
      };
    });

    return tickets;
  } catch (error) {
    console.error("Error fetching Mantis tickets:", error.message);
    // Check if it's an Axios error and provide more details
    if (axios.isAxiosError(error)) {
        console.error("Axios error details:", error.response?.status, error.response?.data);
        throw new Error(`Failed to fetch Mantis tickets: ${error.response?.statusText || error.message}`);
    }
    throw new Error(`Failed to fetch Mantis tickets: ${error.message}`);
  }
}

// --- Forms API --- //

// GET /api/forms - List all forms
router.get('/forms', (req, res) => {
  try {
    const db = getDb();
    const forms = db.prepare('SELECT id, title, description, createdAt FROM forms ORDER BY createdAt DESC').all();
    res.json(forms);
  } catch (err) {
    console.error('Error fetching forms:', err.message);
    res.status(500).json({ error: 'Failed to fetch forms' });
  }
});

// POST /api/forms - Create a new form
router.post('/forms', (req, res) => {
  const { title, description, categories } = req.body;

  if (!title) {
    return res.status(400).json({ error: 'Form title is required' });
  }

  const db = getDb();
  const insertForm = db.prepare('INSERT INTO forms (title, description) VALUES (?, ?)');
  const insertCategory = db.prepare('INSERT INTO categories (formId, name, sortOrder) VALUES (?, ?, ?)');
  const insertField = db.prepare('INSERT INTO fields (categoryId, label, type, description, sortOrder) VALUES (?, ?, ?, ?, ?)');

  const createTransaction = db.transaction((formData) => {
    const { title, description, categories } = formData;
    const formResult = insertForm.run(title, description);
    const formId = formResult.lastInsertRowid;

    if (categories && categories.length > 0) {
      for (const [catIndex, category] of categories.entries()) {
        if (!category.name) throw new Error('Category name is required');

        const catResult = insertCategory.run(formId, category.name, catIndex);
        const categoryId = catResult.lastInsertRowid;

        if (category.fields && category.fields.length > 0) {
          for (const [fieldIndex, field] of category.fields.entries()) {
            if (!field.label || !field.type) {
              throw new Error('Field label and type are required');
            }
            const validTypes = ['text', 'number', 'date', 'textarea', 'boolean'];
            if (!validTypes.includes(field.type)) {
              throw new Error(`Invalid field type: ${field.type}`);
            }
            insertField.run(categoryId, field.label, field.type, field.description || null, fieldIndex);
          }
        }
      }
    }
    return { id: formId, title, description };
  });

  try {
    const resultData = createTransaction({ title, description, categories });
    res.status(201).json(resultData);
  } catch (err) {
    console.error('Error creating form:', err.message);
    res.status(500).json({ error: `Failed to create form: ${err.message}` });
  }
});

// GET /api/forms/:id - Get a specific form with its structure
router.get('/forms/:id', (req, res) => {
  const { id } = req.params;
  try {
    const db = getDb();
    const form = db.prepare('SELECT id, title, description FROM forms WHERE id = ?').get(id);
    if (!form) {
      return res.status(404).json({ error: 'Form not found' });
    }

    const categories = db.prepare(`
      SELECT c.id, c.name, c.sortOrder
      FROM categories c
      WHERE c.formId = ?
      ORDER BY c.sortOrder
    `).all(id);

    const getFieldsStmt = db.prepare(`
      SELECT f.id, f.label, f.type, f.description, f.sortOrder
      FROM fields f
      WHERE f.categoryId = ?
      ORDER BY f.sortOrder
    `);

    for (const category of categories) {
      category.fields = getFieldsStmt.all(category.id);
    }

    form.categories = categories;
    res.json(form);
  } catch (err) {
    console.error(`Error fetching form ${id}:`, err.message);
    res.status(500).json({ error: 'Failed to fetch form details' });
  }
});

// DELETE /api/forms/:id - Delete a specific form and all related data
router.delete('/forms/:id', (req, res) => {
  const formId = req.params.id; // Corrected destructuring

  const db = getDb();
  const checkFormStmt = db.prepare('SELECT id FROM forms WHERE id = ?');
  const deleteValuesStmt = db.prepare('DELETE FROM response_values WHERE responseId IN (SELECT id FROM responses WHERE formId = ?)');
  const deleteResponsesStmt = db.prepare('DELETE FROM responses WHERE formId = ?');
  const deleteFieldsStmt = db.prepare('DELETE FROM fields WHERE categoryId IN (SELECT id FROM categories WHERE formId = ?)');
  const deleteCategoriesStmt = db.prepare('DELETE FROM categories WHERE formId = ?');
  const deleteFormStmt = db.prepare('DELETE FROM forms WHERE id = ?');

  const deleteTransaction = db.transaction((id) => {
    const form = checkFormStmt.get(id);
    if (!form) {
      const err = new Error('Form not found');
      err.statusCode = 404;
      throw err;
    }

    // Delete in order of dependency: values -> responses -> fields -> categories -> form
    deleteValuesStmt.run(id);
    deleteResponsesStmt.run(id);
    deleteFieldsStmt.run(id);
    deleteCategoriesStmt.run(id);
    deleteFormStmt.run(id);

    return { message: `Form ${id} and all related data deleted successfully.` };
  });

  try {
    const resultData = deleteTransaction(formId);
    res.status(200).json(resultData);
  } catch (err) {
    console.error(`Error deleting form ${formId}:`, err.message);
    const statusCode = err.statusCode || 500;
    res.status(statusCode).json({ error: `Failed to delete form: ${err.message}` });
  }
});

// --- Responses API --- //

// POST /api/forms/:id/responses - Submit a response for a form
router.post('/forms/:id/responses', (req, res) => {
  const { id: formId } = req.params;
  const { values } = req.body;

  if (!values || typeof values !== 'object' || Object.keys(values).length === 0) {
    return res.status(400).json({ error: 'Response values are required' });
  }

  const db = getDb();
  const checkFormStmt = db.prepare('SELECT id FROM forms WHERE id = ?');
  const checkFieldStmt = db.prepare('SELECT f.id FROM fields f JOIN categories c ON f.categoryId = c.id WHERE f.id = ? AND c.formId = ?');
  const insertResponseStmt = db.prepare('INSERT INTO responses (formId) VALUES (?)');
  const insertValueStmt = db.prepare('INSERT INTO response_values (responseId, fieldId, value) VALUES (?, ?, ?)');

  const submitTransaction = db.transaction((formIdParam, responseValues) => {
    const form = checkFormStmt.get(formIdParam);
    if (!form) {
      const err = new Error('Form not found');
      err.statusCode = 404;
      throw err;
    }

    const responseResult = insertResponseStmt.run(formIdParam);
    const responseId = responseResult.lastInsertRowid;

    for (const [fieldIdStr, value] of Object.entries(responseValues)) {
      const fieldId = parseInt(fieldIdStr, 10);
      const field = checkFieldStmt.get(fieldId, formIdParam);
      if (!field) {
        console.warn(`Attempted to submit value for field ${fieldId} not belonging to form ${formIdParam}`);
        continue;
      }
      const valueToStore = (value === null || typeof value === 'undefined') ? null : String(value);
      insertValueStmt.run(responseId, fieldId, valueToStore);
    }
    return { responseId };
  });

  try {
    const resultData = submitTransaction(formId, values);
    res.status(201).json(resultData);
  } catch (err) {
    console.error(`Error submitting response for form ${formId}:`, err.message);
    const statusCode = err.statusCode || 500;
    res.status(statusCode).json({ error: `Failed to submit response: ${err.message}` });
  }
});

// GET /api/forms/:id/responses - Get all responses for a form
router.get('/forms/:id/responses', (req, res) => {
  const { id: formId } = req.params;
  try {
    const db = getDb();
    const formExists = db.prepare('SELECT id FROM forms WHERE id = ?').get(formId);
    if (!formExists) {
      return res.status(404).json({ error: 'Form not found' });
    }

    const responses = db.prepare(`
      SELECT r.id as responseId, r.submittedAt,
             rv.fieldId, f.label as fieldLabel, f.type as fieldType, rv.value
      FROM responses r
      JOIN response_values rv ON r.id = rv.responseId
      JOIN fields f ON rv.fieldId = f.id
      JOIN categories c ON f.categoryId = c.id
      WHERE r.formId = ?
      ORDER BY r.submittedAt DESC, r.id, c.sortOrder, f.sortOrder
    `).all(formId);

    const groupedResponses = responses.reduce((acc, row) => {
      const { responseId, submittedAt, fieldId, fieldLabel, fieldType, value } = row;
      if (!acc[responseId]) {
        acc[responseId] = {
          id: responseId,
          submittedAt,
          values: {}
        };
      }
      acc[responseId].values[fieldId] = { label: fieldLabel, type: fieldType, value };
      return acc;
    }, {});

    res.json(Object.values(groupedResponses));
  } catch (err) {
    console.error(`Error fetching responses for form ${formId}:`, err.message);
    res.status(500).json({ error: 'Failed to fetch responses' });
  }
});

// PUT /api/forms/:id - Update an existing form
router.put('/forms/:id', (req, res) => {
  const { id: formId } = req.params;
  const { title, description, categories } = req.body;

  if (!title) {
    return res.status(400).json({ error: 'Form title is required' });
  }

  const db = getDb();
  const checkFormStmt = db.prepare('SELECT id FROM forms WHERE id = ?');
  const updateFormStmt = db.prepare('UPDATE forms SET title = ?, description = ? WHERE id = ?');
  const deleteFieldsStmt = db.prepare('DELETE FROM fields WHERE categoryId IN (SELECT id FROM categories WHERE formId = ?)');
  const deleteCategoriesStmt = db.prepare('DELETE FROM categories WHERE formId = ?');
  const insertCategoryStmt = db.prepare('INSERT INTO categories (formId, name, sortOrder) VALUES (?, ?, ?)');
  const insertFieldStmt = db.prepare('INSERT INTO fields (categoryId, label, type, description, sortOrder) VALUES (?, ?, ?, ?, ?)');

  const updateTransaction = db.transaction((formData) => {
    const { formId, title, description, categories } = formData;

    // 1. Check if form exists
    const existingForm = checkFormStmt.get(formId);
    if (!existingForm) {
      const err = new Error('Form not found');
      err.statusCode = 404;
      throw err;
    }

    // 2. Delete existing categories and fields for this form
    deleteFieldsStmt.run(formId);
    deleteCategoriesStmt.run(formId);

    // 3. Update form details
    updateFormStmt.run(title, description, formId);

    // 4. Re-insert categories and fields
    if (categories && categories.length > 0) {
      for (const [catIndex, category] of categories.entries()) {
        if (!category.name) throw new Error('Category name is required');

        const catResult = insertCategoryStmt.run(formId, category.name, catIndex);
        const categoryId = catResult.lastInsertRowid;

        if (category.fields && category.fields.length > 0) {
          for (const [fieldIndex, field] of category.fields.entries()) {
            if (!field.label || !field.type) {
              throw new Error('Field label and type are required');
            }
            const validTypes = ['text', 'number', 'date', 'textarea', 'boolean'];
            if (!validTypes.includes(field.type)) {
              throw new Error(`Invalid field type: ${field.type}`);
            }
            insertFieldStmt.run(categoryId, field.label, field.type, field.description || null, fieldIndex);
          }
        }
      }
    }
    // Return the updated form ID and title (or potentially the full updated form structure)
    return { id: formId, title, description };
  });

  try {
    const resultData = updateTransaction({ formId, title, description, categories });
    // Optionally fetch the full updated form structure here if needed for the response
    res.status(200).json(resultData); // Send back basic info for now
  } catch (err) {
    console.error(`Error updating form ${formId}:`, err.message);
    const statusCode = err.statusCode || 500;
    res.status(statusCode).json({ error: `Failed to update form: ${err.message}` });
  }
});

router.get('/responses/:responseId/export/pdf', async (req, res) => {
  const { responseId } = req.params;

  try {
    const db = getDb();

    // 1. Fetch the response and its associated form ID
    const response = db.prepare(`
      SELECT r.id, r.formId, r.submittedAt, f.title as formTitle
      FROM responses r
      JOIN forms f ON r.formId = f.id
      WHERE r.id = ?
    `).get(responseId);

    if (!response) {
      return res.status(404).json({ error: 'Response not found' });
    }

    const formId = response.formId;
    const formTitle = response.formTitle;

    // 2. Fetch the form structure (categories and fields)
    const categories = db.prepare(`
      SELECT c.id, c.name
      FROM categories c
      WHERE c.formId = ?
      ORDER BY c.sortOrder
    `).all(formId);

    const getFieldsStmt = db.prepare(`
      SELECT f.id, f.label, f.type, f.description
      FROM fields f
      WHERE f.categoryId = ?
      ORDER BY f.sortOrder
    `);

    for (const category of categories) {
      category.fields = getFieldsStmt.all(category.id);
    }

    // 3. Fetch the values for this specific response
    const valuesResult = db.prepare(`
      SELECT fieldId, value
      FROM response_values
      WHERE responseId = ?
    `).all(responseId);

    const responseValues = valuesResult.reduce((acc, row) => {
      acc[row.fieldId] = (row.value === null || typeof row.value === 'undefined') ? '' : String(row.value);
      return acc;
    }, {});

    // 4. Generate PDF using pdfkit
    const doc = new PDFDocument({ margin: 50, size: 'A4' }); // Set size to A4

    doc.registerFont('Roboto-Bold', join(fontsDir, 'Roboto-Bold.ttf'));
    doc.registerFont('Roboto-SemiBold', join(fontsDir, 'Roboto-SemiBold.ttf'));
    doc.registerFont('Roboto-Italics', join(fontsDir, 'Roboto-Italic.ttf'));
    doc.registerFont('Roboto-Regular', join(fontsDir, 'Roboto-Regular.ttf'));

    res.setHeader('Content-Type', 'application/pdf');
    res.setHeader('Content-Disposition', `inline; filename=response_${responseId}_${formTitle.replace(/[\s\\/]/g, '_') || 'form'}.pdf`); // Use inline to preview

    doc.pipe(res);

    // --- PDF Content ---

    // Title
    doc.fontSize(18).font('Roboto-Bold').text(formTitle, { align: 'center' });
    doc.moveDown();

    // Iterate through categories and fields
    for (const category of categories) {
      if (category.name) {
         doc.fontSize(14).font('Roboto-Bold').text(category.name);
         doc.moveDown(0.5);
      }

      for (const field of category.fields) {
        const value = responseValues[field.id] || ''; // Get the value for this field

        // Field Label
        doc.fontSize(12).font('Roboto-SemiBold').text(field.label + ':', { continued: false }); // Use continued: false to reset position potentially
        // Optional: Add description
        if (field.description) {
            doc.fontSize(9).font('Roboto-Italics').text(field.description);
        }
        doc.moveDown(0.2);

        // Field Value (mimic input)
        doc.fontSize(11).font('Roboto-Regular');
        if (field.type === 'textarea') {
          // Draw a box and put text inside for textarea
          const textHeight = doc.heightOfString(value, { width: 500 }); // Estimate height
          doc.rect(doc.x, doc.y, 500, Math.max(textHeight + 10, 30)).stroke(); // Draw rectangle
          doc.text(value, doc.x + 5, doc.y + 5, { width: 490 }); // Add text inside with padding
          doc.y += Math.max(textHeight + 10, 30) + 10; // Move below the box
        } else if (field.type === 'date') {
          // Format date as DD/MM/YYYY
          let formattedDate = '';
          if (value) {
            try {
              const dateObj = new Date(value + 'T00:00:00'); // Add time part to avoid timezone issues with just YYYY-MM-DD
              if (!isNaN(dateObj.getTime())) {
                const day = String(dateObj.getDate()).padStart(2, '0');
                const month = String(dateObj.getMonth() + 1).padStart(2, '0'); // Month is 0-indexed
                const year = dateObj.getFullYear();
                formattedDate = `${day}/${month}/${year}`;
              } else {
                formattedDate = value; // Keep original if invalid
              }
            } catch (e) {
              console.error('Error formatting date:', value, e);
              formattedDate = value; // Keep original on error
            }
          }
          doc.text(formattedDate || ' '); // Add space if empty
          doc.lineCap('butt').moveTo(doc.x, doc.y).lineTo(doc.x + 500, doc.y).stroke(); // Draw line underneath
          doc.moveDown(1.5); // Space between fields
        } else if (field.type === 'boolean') {
          // Display boolean as Yes/No
          const displayValue = value === 'true' ? 'Yes' : (value === 'false' ? 'No' : ' ');
          doc.text(displayValue);
          doc.lineCap('butt').moveTo(doc.x, doc.y).lineTo(doc.x + 500, doc.y).stroke(); // Draw line underneath
          doc.moveDown(1.5); // Space between fields
        } else {
          // Simple line for other types
          doc.text(value || ' '); // Add space if empty to ensure line moves
          doc.lineCap('butt').moveTo(doc.x, doc.y).lineTo(doc.x + 500, doc.y).stroke(); // Draw line underneath
          doc.moveDown(1.5); // Space between fields
        }
      }
       doc.moveDown(1); // Space between categories
    }

    // --- Finalize PDF ---
    doc.end();

  } catch (err) {
    console.error(`Error generating PDF for response ${responseId}:`, err.message);
    if (!res.headersSent) {
      res.status(500).json({ error: 'Failed to generate PDF' });
    } else {
      console.error("Headers already sent, could not send JSON error for PDF generation failure.");
      // Ensure the stream is ended if an error occurs after piping
      res.end();
    }
  }
});

// --- Mantis Summary API --- //

router.get('/mantis-summary', async (req, res) => {
  if (!ai) {
    return res.status(500).json({ error: 'Google AI API key not configured.' });
  }
  if (!fs.existsSync(promptFilePath)) {
     return res.status(500).json({ error: `Prompt file not found at ${promptFilePath}` });
  }

  try {
    // Read the prompt from the file
    let promptTemplate = fs.readFileSync(promptFilePath, 'utf8');
    const tickets = await getMantisTickets();

    if (tickets.length === 0) {
        return res.json({ summary: "No Mantis tickets updated recently." });
    }

    let prompt = promptTemplate.replaceAll("$DATE", new Date().toISOString().split('T')[0]);
    prompt = prompt.replaceAll("$MANTIS_TICKETS", JSON.stringify(tickets, null, 2));

    // Use the specific model and configuration from your original script
    const model = ai.getGenerativeModel({ model: "gemini-2.5-flash-exp" }); // Or your specific model like "gemini-2.0-flash-exp" if available
    const result = await model.generateContent(prompt);
    const response = await result.response;
    const summaryText = response.text();


    res.json({ summary: summaryText });

  } catch (error) {
    console.error("Error generating Mantis summary:", error);
    res.status(500).json({ error: `Failed to generate summary: ${error.message}` });
  }
});

export default router;