const fs = require('fs');
const path = require('path');
const { PrismaClient } = require('@prisma/client');
const { PrismaPg } = require('@prisma/adapter-pg');
const { Pool } = require('pg');
require('dotenv').config();

// Base configurations - Target the dev server directly via localhost port
const BASE_URL = "http://127.0.0.1:3001";

let prisma;
let pool;
const deployedWorkflowIds = [];
let n8nUrl;
let n8nApiKey;

// Helper to run query with admin credentials
function getPrisma() {
  if (!prisma) {
    const dbUrl = new URL(process.env.DATABASE_URL_DEV || process.env.DATABASE_URL);
    pool = new Pool({
      host: dbUrl.hostname,
      port: dbUrl.port ? parseInt(dbUrl.port) : 5432,
      user: decodeURIComponent(dbUrl.username),
      password: decodeURIComponent(dbUrl.password),
      database: dbUrl.pathname.substring(1).split('?')[0],
      ssl: false
    });
    const adapter = new PrismaPg(pool);
    prisma = new PrismaClient({ adapter });
  }
  return prisma;
}

async function runAsAdmin(queryFn) {
  const db = getPrisma();
  return db.$transaction(async (tx) => {
    await tx.$executeRawUnsafe(`SET LOCAL app.current_user_role = 'admin';`);
    return queryFn(tx);
  });
}

async function sleep(ms) {
  return new Promise(resolve => setTimeout(resolve, ms));
}

// Custom simple assertion
let passed = 0;
let failed = 0;
function assert(condition, message) {
  if (condition) {
    console.log(`  ✓ PASS: ${message}`);
    passed++;
  } else {
    console.error(`  ✗ FAIL: ${message}`);
    failed++;
  }
}

async function cleanupDb() {
  console.log("Cleaning up integration test records in test database...");
  try {
    await runAsAdmin(async (tx) => {
      // Clean sales results
      await tx.salesResult.deleteMany({
        where: {
          OR: [
            { idempotencyKey: { startsWith: 'key-integration' } },
            { period: '2026-07' }
          ]
        }
      });
      // Clean import jobs
      if (tx.salesImportJob) {
        await tx.salesImportJob.deleteMany({
          where: {
            idempotencyKey: { startsWith: 'key-integration' }
          }
        });
      }
      // Clean settlements
      await tx.settlement.deleteMany({
        where: {
          period: '2026-07'
        }
      });
      // Clean goals
      await tx.goal.deleteMany({
        where: {
          period: '2026-07'
        }
      });
      // Clean test plans
      await tx.calculationRule.deleteMany({
        where: { plan: { code: 'PLAN-INT-P5' } }
      });
      await tx.compensationPlan.deleteMany({
        where: { code: 'PLAN-INT-P5' }
      });
      // Clean audit logs
      await tx.auditLog.deleteMany({
        where: {
          action: 'CREATE',
          targetTable: 'sales_results'
        }
      });
    });
  } catch (err) {
    console.error("Error during DB cleanup:", err);
  }
}

async function runTests() {
  console.log("=== STARTING REAL N8N E2E INTEGRATION TEST SUITE ===");

  // 1. Clean DB
  await cleanupDb();

  // 2. Fetch n8n API configuration
  const mcpConfigPath = path.join(__dirname, '../.agents/mcp_config.json');
  if (!fs.existsSync(mcpConfigPath)) {
    console.error("Error: .agents/mcp_config.json not found.");
    process.exit(1);
  }
  
  const mcpConfig = JSON.parse(fs.readFileSync(mcpConfigPath, 'utf8'));
  const n8nEnv = mcpConfig.mcpServers.n8n.env;
  n8nUrl = n8nEnv.N8N_API_URL || "https://n8n.gaboggamer.online";
  n8nApiKey = n8nEnv.N8N_API_KEY;

  if (!n8nApiKey) {
    console.error("Error: N8N_API_KEY is missing in mcp_config.json.");
    process.exit(1);
  }

  // 3. Fetch existing workflows to retrieve the project ID dynamically
  console.log("Fetching project ID from existing workflows...");
  let projectId;
  try {
    const listRes = await fetch(`${n8nUrl}/api/v1/workflows`, {
      method: 'GET',
      headers: {
        'X-N8N-API-KEY': n8nApiKey
      }
    });
    if (listRes.ok) {
      const listData = await listRes.json();
      const firstWf = listData.data.find(w => w.shared && w.shared.length > 0);
      if (firstWf) {
        projectId = firstWf.shared[0].projectId;
        console.log(`Resolved project ID dynamically: ${projectId}`);
      }
    }
  } catch (err) {
    console.warn("Warning: Could not fetch project ID dynamically, falling back to default.", err.message);
  }

  // 4. Fetch credentials dynamically to resolve AI accounts
  console.log("Fetching credentials from n8n to resolve AI accounts...");
  let deepSeekCred = null;
  let geminiCred = null;
  try {
    const credsRes = await fetch(`${n8nUrl}/api/v1/credentials`, {
      method: 'GET',
      headers: {
        'X-N8N-API-KEY': n8nApiKey
      }
    });
    if (credsRes.ok) {
      const credsData = await credsRes.json();
      const credentials = Array.isArray(credsData.data) ? credsData.data : (credsData.data.credentials || []);
      
      const deepSeekCreds = credentials.filter(c => c.type === 'deepSeekApi');
      if (deepSeekCreds.length > 0) {
        deepSeekCred = deepSeekCreds.find(c => c.name.toLowerCase().includes('deepseek')) || deepSeekCreds[0];
      }
      
      const geminiCreds = credentials.filter(c => c.type === 'googlePalmApi');
      if (geminiCreds.length > 0) {
        geminiCred = geminiCreds.find(c => c.name.toLowerCase().includes('gemini') || c.name.toLowerCase().includes('google')) || geminiCreds[0];
      }
    }
  } catch (err) {
    console.warn("Warning: Could not fetch credentials dynamically:", err.message);
  }

  // 5. Verify the external dev server is running
  console.log(`Verifying target dev server at ${BASE_URL}...`);
  try {
    const res = await fetch(`${BASE_URL}/api/auth/me`);
    if (!res.ok) {
      console.warn(`Warning: Target server returned status ${res.status}`);
    }
  } catch (e) {
    console.error(`Error: Dev server is unreachable at ${BASE_URL}. Error:`, e.message);
    await cleanup();
    process.exit(1);
  }

  // ==========================================
  // TEST CASE 1: SALES IMPORT WORKFLOW
  // ==========================================
  console.log("\n[Test 1] Deploying and triggering Sales Import Workflow...");
  const importWorkflowPath = path.join(__dirname, '../n8n/sales_import_workflow.json');
  if (!fs.existsSync(importWorkflowPath)) {
    console.error("Error: n8n/sales_import_workflow.json not found.");
    process.exit(1);
  }

  const importWfJson = JSON.parse(fs.readFileSync(importWorkflowPath, 'utf8'));
  const importWebhookPath = `calculate-commissions-${Date.now()}`;

  // Configure dev app urls and webhooks
  for (const node of importWfJson.nodes) {
    if (node.id === 'Set-Dev-Env' || node.id === 'Set-Prod-Env') {
      node.parameters.values.string = [
        { name: 'appUrl', value: 'http://special-hotel-dev:3000' },
        { name: 'signature', value: process.env.N8N_WEBHOOK_SECRET_DEV || 'qUHuPqPjA65psdtwQU7zgp/DVkvd1xXk2WP/vzbnEdc=' }
      ];
    }
    if (node.type === 'n8n-nodes-base.webhook') {
      node.parameters.path = importWebhookPath;
    }
    if (node.type === '@n8n/n8n-nodes-langchain.lmChatDeepSeek' && deepSeekCred) {
      node.credentials = { deepSeekApi: { id: deepSeekCred.id, name: deepSeekCred.name } };
    }
    if (node.type === '@n8n/n8n-nodes-langchain.lmChatGoogleGemini' && geminiCred) {
      node.credentials = { googlePalmApi: { id: geminiCred.id, name: geminiCred.name } };
    }
  }

  const importWfName = `Semillero E2E Integration: Sales Import - ${Date.now()}`;
  const importCreateRes = await fetch(`${n8nUrl}/api/v1/workflows`, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json', 'X-N8N-API-KEY': n8nApiKey },
    body: JSON.stringify({
      name: importWfName,
      nodes: importWfJson.nodes,
      connections: importWfJson.connections,
      settings: importWfJson.settings || {},
      projectId
    })
  });

  if (!importCreateRes.ok) {
    console.error("Failed to deploy import workflow:", await importCreateRes.text());
    process.exit(1);
  }
  const importWfData = await importCreateRes.json();
  deployedWorkflowIds.push(importWfData.id);

  // Activate import workflow
  await fetch(`${n8nUrl}/api/v1/workflows/${importWfData.id}/activate`, {
    method: 'POST',
    headers: { 'X-N8N-API-KEY': n8nApiKey }
  });
  await sleep(3000);

  const importIdempotencyKey = `key-integration-import-${Date.now()}`;
  const uploadRes = await fetch(`${n8nUrl}/webhook/${importWebhookPath}`, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'x-n8n-signature': process.env.N8N_WEBHOOK_SECRET_DEV || 'qUHuPqPjA65psdtwQU7zgp/DVkvd1xXk2WP/vzbnEdc='
    },
    body: JSON.stringify({
      idempotencyKey: importIdempotencyKey,
      uploaderId: 1,
      sales: [
        {
          username: 'colaborador_mde',
          hotelCode: 'EST-MDE',
          period: '2026-06',
          amount: 15000,
          salesCount: 5,
          transactionId: `TX-INT-COMM-${Date.now()}`
        }
      ]
    })
  });

  assert(uploadRes.status === 200 || uploadRes.status === 202, `Import webhook response code: ${uploadRes.status}`);
  const uploadData = await uploadRes.json();
  assert(uploadData.success && uploadData.code === 'IMPORT_ACCEPTED', "Import accepted by n8n");

  let importCallbackCompleted = false;
  for (let i = 0; i < 20; i++) {
    await sleep(2000);
    const dbSales = await runAsAdmin(tx => tx.salesResult.findMany({
      where: { idempotencyKey: { startsWith: importIdempotencyKey } }
    }));
    if (dbSales.length > 0) {
      assert(dbSales.length === 1, "Sales result saved to dev database by n8n callback");
      assert(parseFloat(dbSales[0].amount) === 15000.00, "Imported amount verified");
      importCallbackCompleted = true;
      break;
    }
  }
  assert(importCallbackCompleted, "Sales import integration completed successfully");

  // ==========================================
  // TEST CASE 2: SETTLEMENT CALCULATION WORKFLOW
  // ==========================================
  console.log("\n[Test 2] Deploying and triggering Settlement Calculation Workflow...");
  const calcWorkflowPath = path.join(__dirname, '../n8n/settlement_calculation_workflow.json');
  if (!fs.existsSync(calcWorkflowPath)) {
    console.error("Error: n8n/settlement_calculation_workflow.json not found.");
    await cleanup();
    process.exit(1);
  }

  const calcWfJson = JSON.parse(fs.readFileSync(calcWorkflowPath, 'utf8'));
  const calcWebhookPath = `calculate-settlements-${Date.now()}`;

  // Configure dev app urls and webhooks
  for (const node of calcWfJson.nodes) {
    if (node.id === 'Set-Dev-Env' || node.id === 'Set-Prod-Env') {
      node.parameters.values.string = [
        { name: 'appUrl', value: 'http://special-hotel-dev:3000' },
        { name: 'signature', value: process.env.N8N_WEBHOOK_SECRET_DEV || 'qUHuPqPjA65psdtwQU7zgp/DVkvd1xXk2WP/vzbnEdc=' }
      ];
    }
    if (node.type === 'n8n-nodes-base.webhook') {
      node.parameters.path = calcWebhookPath;
    }
    if (node.type === '@n8n/n8n-nodes-langchain.lmChatDeepSeek' && deepSeekCred) {
      node.credentials = { deepSeekApi: { id: deepSeekCred.id, name: deepSeekCred.name } };
    }
    if (node.type === '@n8n/n8n-nodes-langchain.lmChatGoogleGemini' && geminiCred) {
      node.credentials = { googlePalmApi: { id: geminiCred.id, name: geminiCred.name } };
    }
  }

  const calcWfName = `Semillero E2E Integration: Settlement Calc - ${Date.now()}`;
  const calcCreateRes = await fetch(`${n8nUrl}/api/v1/workflows`, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json', 'X-N8N-API-KEY': n8nApiKey },
    body: JSON.stringify({
      name: calcWfName,
      nodes: calcWfJson.nodes,
      connections: calcWfJson.connections,
      settings: calcWfJson.settings || {},
      projectId
    })
  });

  if (!calcCreateRes.ok) {
    console.error("Failed to deploy calculation workflow:", await calcCreateRes.text());
    await cleanup();
    process.exit(1);
  }
  const calcWfData = await calcCreateRes.json();
  deployedWorkflowIds.push(calcWfData.id);

  // Activate calculation workflow
  await fetch(`${n8nUrl}/api/v1/workflows/${calcWfData.id}/activate`, {
    method: 'POST',
    headers: { 'X-N8N-API-KEY': n8nApiKey }
  });
  await sleep(3000);

  // Seed DB records for the calculation E2E test
  console.log("Seeding test database with plan, rules, goal, and sales results for calculation E2E test...");
  const adminUser = (await runAsAdmin(tx => tx.user.findMany())).find(u => u.username === 'admin');
  const colaboradorMde = (await runAsAdmin(tx => tx.user.findMany())).find(u => u.username === 'colaborador_mde');

  const testPlan = await runAsAdmin(async (tx) => {
    // Delete existing PLAN-INT-P5 if any
    await tx.calculationRule.deleteMany({ where: { plan: { code: 'PLAN-INT-P5' } } });
    await tx.compensationPlan.deleteMany({ where: { code: 'PLAN-INT-P5' } });

    const plan = await tx.compensationPlan.create({
      data: {
        name: 'Integration Test Plan Phase 5',
        code: 'PLAN-INT-P5',
        validityStart: new Date('2026-01-01'),
        type: 'SCALE',
        status: 'ACTIVE',
        version: 1,
        createdBy: adminUser.id
      }
    });

    await tx.calculationRule.create({
      data: {
        planId: plan.id,
        type: 'TIER',
        minAchievement: 0.0,
        maxAchievement: 2.0,
        rate: 0.02,
        payoutAmount: 0.0
      }
    });

    return plan;
  });

  // Seed Goal and SalesResult for period 2026-07
  await runAsAdmin(async (tx) => {
    await tx.goal.deleteMany({ where: { period: '2026-07', targetId: colaboradorMde.id } });
    await tx.goal.create({
      data: {
        targetType: 'INDIVIDUAL',
        targetId: colaboradorMde.id,
        period: '2026-07',
        amount: 10000.00
      }
    });

    await tx.salesResult.deleteMany({ where: { period: '2026-07', userId: colaboradorMde.id } });
    await tx.salesResult.create({
      data: {
        source: 'API',
        hotelId: colaboradorMde.hotelId,
        userId: colaboradorMde.id,
        period: '2026-07',
        amount: 5000.00,
        salesCount: 2,
        idempotencyKey: 'key-integration-sales-p5',
        uploadedBy: adminUser.id,
        status: 'PENDING'
      }
    });
  });

  // Trigger calculation webhook (commit mode)
  console.log(`Triggering settlement calculation webhook directly at ${n8nUrl}/webhook/${calcWebhookPath}...`);
  const calcRes = await fetch(`${n8nUrl}/webhook/${calcWebhookPath}`, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'x-n8n-signature': process.env.N8N_WEBHOOK_SECRET_DEV || 'qUHuPqPjA65psdtwQU7zgp/DVkvd1xXk2WP/vzbnEdc='
    },
    body: JSON.stringify({
      period: '2026-07',
      simulateOnly: false,
      uploaderId: adminUser.id
    })
  });

  assert(calcRes.status === 200 || calcRes.status === 201, `Calculation webhook response code: ${calcRes.status}`);
  const calcData = await calcRes.json();
  assert(calcData.success && calcData.code === 'SETTLEMENTS_CALCULATED', "Calculation execution successful");

  // Verify settlement created in database
  const finalSettlement = await runAsAdmin(tx => tx.settlement.findFirst({
    where: {
      userId: colaboradorMde.id,
      period: '2026-07',
      planId: testPlan.id
    }
  }));

  assert(finalSettlement !== null, "Settlement record created in database for colaborador_mde in 2026-07");
  if (finalSettlement) {
    assert(finalSettlement.status === 'PENDING', "Settlement status is set to PENDING");
    assert(parseFloat(finalSettlement.calculatedCommission) === 100.00, "Calculated commission is correctly 100.00 (5,000 * 2%)");
    assert(parseFloat(finalSettlement.totalPayout) === 100.00, "Total payout is correctly 100.00");
  }

  await cleanup();

  console.log(`\n=== REAL N8N INTEGRATION TEST RESULTS: ${passed} PASSED, ${failed} FAILED ===`);
  if (failed > 0) {
    process.exit(1);
  } else {
    process.exit(0);
  }
}

async function cleanup() {
  console.log("\nCleaning up integration test processes...");
  
  // 1. Delete all deployed workflows from n8n
  for (const id of deployedWorkflowIds) {
    if (failed > 0) {
      console.log(`[TEST FAILED] Skipping test workflow ${id} deletion to allow troubleshooting in n8n.gaboggamer.online.`);
    } else {
      console.log(`Deleting n8n test workflow ${id}...`);
      try {
        const delRes = await fetch(`${n8nUrl}/api/v1/workflows/${id}`, {
          method: 'DELETE',
          headers: {
            'X-N8N-API-KEY': n8nApiKey
          }
        });
        if (delRes.ok) {
          console.log(`Test workflow ${id} deleted successfully from n8n.`);
        } else {
          console.error(`Failed to delete test workflow ${id}:`, await delRes.text());
        }
      } catch (e) {
        console.error(`Error deleting workflow ${id}:`, e);
      }
    }
  }

  // 3. Clean DB records
  await cleanupDb();

  // 4. Disconnect Prisma
  try {
    if (prisma) {
      await prisma.$disconnect();
    }
    if (pool) {
      await pool.end();
    }
  } catch (e) {}
}

process.on('SIGINT', async () => {
  await cleanup();
  process.exit(1);
});

runTests().catch(async err => {
  console.error("Fatal E2E integration test runner error:", err);
  failed++;
  await cleanup();
  process.exit(1);
});