const express = require('express');
const { APP_PORTS, ARR_SERVICES } = require('../../constants');

module.exports = function(ctx, helpers) {
  const router = express.Router();

  // Detect running arr services and their configurations
  router.get('/arr/detect', ctx.asyncHandler(async (req, res) => {
    const containers = await ctx.docker.client.listContainers({ all: false });
    const detected = {
      plex: null,
      radarr: null,
      sonarr: null,
      overseerr: null,
      lidarr: null,
      prowlarr: null
    };

    // Service detection patterns
    const servicePatterns = ARR_SERVICES;

    for (const container of containers) {
      const containerName = container.Names[0]?.replace(/^\//, '').toLowerCase() || '';
      const image = container.Image.toLowerCase();

      for (const [service, config] of Object.entries(servicePatterns)) {
        if (config.names.some(n => containerName.includes(n) || image.includes(n))) {
          // Find the exposed port
          const portInfo = container.Ports.find(p => p.PrivatePort === config.port);
          const exposedPort = portInfo?.PublicPort || config.port;

          detected[service] = {
            containerId: container.Id,
            containerName: container.Names[0]?.replace(/^\//, ''),
            image: container.Image,
            port: exposedPort,
            status: container.State,
            url: helpers.getServiceUrl(containerName, exposedPort)
          };

          // Get API key for arr services (not Plex or Overseerr)
          if (['radarr', 'sonarr', 'lidarr', 'prowlarr'].includes(service)) {
            detected[service].apiKey = await helpers.getArrApiKey(containerName);
          }
        }
      }
    }

    // Get Plex token if Plex is detected
    if (detected.plex) {
      detected.plex.token = await helpers.getPlexToken(detected.plex.containerName);
    }

    res.json({
      success: true,
      services: detected,
      summary: {
        plexReady: !!(detected.plex?.token),
        radarrReady: !!(detected.radarr?.apiKey),
        sonarrReady: !!(detected.sonarr?.apiKey),
        overseerrRunning: !!detected.overseerr
      }
    });
  }, 'arr-detect'));

  // Smart Detect: Unified discovery of all arr services
  router.get('/arr/smart-detect', ctx.asyncHandler(async (req, res) => {
    const serviceList = ['plex', 'radarr', 'sonarr', 'prowlarr', 'seerr'];
    const defaultPorts = APP_PORTS;
    const result = {};

    // 1. Scan Docker containers
    let containers = [];
    try { containers = await ctx.docker.client.listContainers({ all: false }); } catch (e) { /* Docker not available */ }

    const servicePatterns = ARR_SERVICES;

    const dockerDetected = {};
    for (const container of containers) {
      const containerName = container.Names[0]?.replace(/^\//, '').toLowerCase() || '';
      const image = container.Image.toLowerCase();
      for (const [svc, config] of Object.entries(servicePatterns)) {
        if (config.names.some(n => containerName.includes(n) || image.includes(n))) {
          const portInfo = container.Ports.find(p => p.PrivatePort === config.port);
          dockerDetected[svc] = {
            containerId: container.Id,
            containerName: container.Names[0]?.replace(/^\//, ''),
            port: portInfo?.PublicPort || config.port,
            status: container.State
          };
        }
      }
    }

    // 2. Load services.json for external entries
    let storedServices = [];
    try {
      const data = await ctx.servicesStateManager.read();
      storedServices = Array.isArray(data) ? data : data.services || [];
    } catch (e) { /* ignore */ }

    // 3. Load stored credentials
    const storedCreds = {};
    const seedboxBaseUrl = await ctx.credentialManager.retrieve('arr.seedbox.baseurl');

    for (const svc of serviceList) {
      const credKey = svc === 'plex' ? 'arr.plex.token' : `arr.${svc}.apikey`;
      const apiKey = await ctx.credentialManager.retrieve(credKey);
      const metadata = await ctx.credentialManager.getMetadata(credKey);
      if (apiKey) {
        storedCreds[svc] = { apiKey, metadata };
      }
    }

    // 4. Build detection result for each service
    for (const svc of serviceList) {
      const entry = {
        status: 'not_found',
        source: null,
        url: null,
        hasApiKey: false,
        hasToken: false,
        containerId: null,
        containerName: null,
        version: null
      };

      // Check Docker first
      if (dockerDetected[svc]) {
        const dc = dockerDetected[svc];
        entry.containerId = dc.containerId;
        entry.containerName = dc.containerName;
        entry.source = 'local';
        entry.url = `http://localhost:${dc.port}`;

        if (svc === 'plex') {
          // Try to get Plex token from container
          try {
            const token = await helpers.getPlexToken(dc.containerName);
            if (token) {
              entry.hasToken = true;
              entry.status = 'connected';
              // Store for later use
              await ctx.credentialManager.store('arr.plex.token', token, {
                service: 'plex', source: 'local', url: entry.url,
                lastVerified: new Date().toISOString()
              });
            } else {
              entry.status = 'needs_key';
            }
          } catch (e) { entry.status = 'needs_key'; }
        } else if (svc === 'seerr') {
          entry.status = 'connected';
          // Check what Overseerr has configured using Plex-based session auth
          try {
            const session = await helpers.getOverseerrSession();
            if (session) {
              entry.hasApiKey = true;
              const configuredServices = { radarr: false, sonarr: false, plex: false };
              try {
                const radarrCheck = await ctx.fetchT(`http://host.docker.internal:${dc.port}/api/v1/settings/radarr`, {
                  headers: { 'Cookie': session.cookie },
                  signal: AbortSignal.timeout(5000)
                });
                if (radarrCheck.ok) {
                  const radarrSettings = await radarrCheck.json();
                  configuredServices.radarr = Array.isArray(radarrSettings) ? radarrSettings.length > 0 : !!radarrSettings;
                }
              } catch (e) { /* ignore */ }
              try {
                const sonarrCheck = await ctx.fetchT(`http://host.docker.internal:${dc.port}/api/v1/settings/sonarr`, {
                  headers: { 'Cookie': session.cookie },
                  signal: AbortSignal.timeout(5000)
                });
                if (sonarrCheck.ok) {
                  const sonarrSettings = await sonarrCheck.json();
                  configuredServices.sonarr = Array.isArray(sonarrSettings) ? sonarrSettings.length > 0 : !!sonarrSettings;
                }
              } catch (e) { /* ignore */ }
              try {
                const plexCheck = await ctx.fetchT(`http://host.docker.internal:${dc.port}/api/v1/settings/plex`, {
                  headers: { 'Cookie': session.cookie },
                  signal: AbortSignal.timeout(5000)
                });
                if (plexCheck.ok) {
                  const plexSettings = await plexCheck.json();
                  configuredServices.plex = !!plexSettings?.ip;
                }
              } catch (e) { /* ignore */ }
              entry.configuredServices = configuredServices;
            }
          } catch (e) { /* ignore */ }
        } else {
          // arr services - try to get API key from container
          try {
            const key = await helpers.getArrApiKey(dc.containerName);
            if (key) {
              entry.hasApiKey = true;
              entry.status = 'connected';
            } else {
              entry.status = storedCreds[svc] ? 'connected' : 'needs_key';
              entry.hasApiKey = !!storedCreds[svc];
            }
          } catch (e) {
            entry.status = storedCreds[svc] ? 'connected' : 'needs_key';
            entry.hasApiKey = !!storedCreds[svc];
          }
        }
      }

      // Check external services from services.json
      if (entry.status === 'not_found') {
        const externalService = storedServices.find(s => s.id === svc && s.isExternal);
        if (externalService?.externalUrl) {
          entry.source = 'external';
          entry.url = externalService.externalUrl;

          if (storedCreds[svc]) {
            entry.hasApiKey = true;
            entry.version = storedCreds[svc].metadata?.version || null;
            // Verify connection is still good
            const test = await helpers.testServiceConnection(svc, entry.url, storedCreds[svc].apiKey);
            entry.status = test.success ? 'connected' : 'error';
            if (test.success) entry.version = test.version;
          } else {
            entry.status = 'needs_key';
          }
        }
      }

      // Check stored credentials with metadata URL
      if (entry.status === 'not_found' && storedCreds[svc]?.metadata?.url) {
        entry.source = 'stored';
        entry.url = storedCreds[svc].metadata.url;
        entry.hasApiKey = true;
        entry.version = storedCreds[svc].metadata?.version || null;
        entry.status = 'connected';
      }

      // For plex, also check stored token
      if (svc === 'plex' && entry.status === 'not_found' && storedCreds.plex) {
        entry.hasToken = true;
        entry.source = 'stored';
        entry.url = storedCreds.plex.metadata?.url || `http://localhost:${defaultPorts.plex}`;
        entry.status = 'connected';
      }

      result[svc] = entry;
    }

    // 5. Detect seedbox base URL pattern
    let detectedSeedboxUrl = seedboxBaseUrl || null;
    if (!detectedSeedboxUrl) {
      const externalUrls = storedServices
        .filter(s => s.isExternal && s.externalUrl)
        .map(s => s.externalUrl);
      if (externalUrls.length > 0) {
        // Find common base URL pattern
        try {
          const url = new URL(externalUrls[0]);
          const pathParts = url.pathname.split('/').filter(p => p);
          if (pathParts.length >= 2) {
            detectedSeedboxUrl = `${url.origin}/${pathParts[0]}`;
          }
        } catch (e) { /* ignore */ }
      }
    }

    // Summary
    const statuses = Object.values(result);
    const summary = {
      totalDetected: statuses.filter(s => s.status !== 'not_found').length,
      fullyConnected: statuses.filter(s => s.status === 'connected').length,
      needsApiKey: statuses.filter(s => s.status === 'needs_key').length,
      errors: statuses.filter(s => s.status === 'error').length,
      readyForAutoConnect: statuses.filter(s => s.status === 'connected').length >= 2
    };

    res.json({ success: true, services: result, seedboxBaseUrl: detectedSeedboxUrl, summary });
  }, 'smart-detect'));

  return router;
};