import { Router } from 'express';
import { WIFI_CLIENT_SETTINGS_KEY } from 'types/wifiClient';
import { getPrivateConfig, updatePrivateConfig } from 'sqlite/privateConfig';
import { WifiClientSecurity } from 'types/wifiClient';
import { wifiClientManager } from 'util/wifiClient/wifiClientClass';
import { getWifiClientStatus } from 'util/wifiClient/wifiClientConnection';
import {
  checkCompatibility,
  scanForWifiNetworks,
} from 'util/wifiClient/wifiClientScan';
import { killWifiClient } from 'util/wifiClient/wifiClientStatusHelpers';

const router = Router();

router.get('/settings', async (req, res) => {
  try {
    const wifiConfig = await getPrivateConfig(WIFI_CLIENT_SETTINGS_KEY);
    if (wifiConfig?.password) {
      wifiConfig.password = '********'; // Mask the password
    }
    res.json({
      wifiClientSettings: {
        ssid: wifiConfig?.ssid || '',
        password: wifiConfig?.password || '',
        enabled: wifiConfig?.enabled === true,
        security: wifiConfig?.security || '',
      },
    });
  } catch (error) {
    console.error('Error retrieving WiFi client settings:', error);
    return res
      .status(500)
      .json({ error: 'Failed to retrieve WiFi client settings' });
  }
});

router.post('/settings', async (req, res) => {
  const { ssid, password, enabled, security, freq } = req.body;
  console.log('From /wifiClient/settings', ssid, enabled, security, freq);
  if (
    typeof ssid !== 'string' ||
    typeof password !== 'string' ||
    typeof enabled !== 'string' ||
    typeof security !== 'string' ||
    typeof freq !== 'number'
  ) {
    return res.status(400).json({ error: 'Invalid input data' });
  }

  try {
    if (ssid !== '' && password !== '' && freq !== 0) {
      checkCompatibility(ssid, password, security as WifiClientSecurity, freq);
    }
  } catch (error) {
    console.error('Error checking wifi compatibility:', error);

    if (error instanceof Error) {
      return res.status(500).json({ error: error.message });
    } else {
      return res.status(500).json({ error: 'Failed to reset WiFi client' });
    }
  }

  if (enabled !== 'true' && enabled !== 'false') {
    return res.status(400).json({ error: 'Enabled must be true or false' });
  }
  const enabledBoolean = enabled === 'true' ? true : false;

  let securityEnum = WifiClientSecurity.Open;
  if (security.toLowerCase() === WifiClientSecurity.WPA2.toLowerCase()) {
    securityEnum = WifiClientSecurity.WPA2;
  } else if (security.toLowerCase() === WifiClientSecurity.Open.toLowerCase()) {
    securityEnum = WifiClientSecurity.Open;
  } else {
    return res.status(400).json({
      error: 'Invalid security type. Must be either WPA2 or Open',
    });
  }

  try {
    await updatePrivateConfig({
      wifiClientSettings: {
        ssid,
        password,
        enabled: enabledBoolean,
        security: securityEnum,
        freq: freq,
      },
    });
    const wifiConfig = await getPrivateConfig(WIFI_CLIENT_SETTINGS_KEY);
    console.log('Updated WiFi client settings:', ssid, securityEnum, freq);
    await killWifiClient();
    console.log('Calling reset wifi client from /settings');
    void wifiClientManager.resetWifiClient(
      ssid,
      password,
      securityEnum,
      freq,
      true, // Force reset to ensure the client is reconfigured
    );
  } catch (error) {
    console.error('Error updating WiFi client settings:', error);
    return res
      .status(500)
      .json({ error: 'Failed to update WiFi client settings' });
  }
  console.log('WiFi client settings updated successfully');
  res.json({
    message: 'WiFi client settings updated successfully',
  });
});

router.post('/enable', async (req, res) => {
  const { enabled } = req.body;

  if (typeof enabled !== 'boolean') {
    return res.status(400).json({ error: 'enabled must be a boolean value' });
  }

  try {
    const wifiConfig = await getPrivateConfig(WIFI_CLIENT_SETTINGS_KEY);

    if (!wifiConfig || !wifiConfig.ssid || !wifiConfig.password) {
      return res.status(400).json({ error: 'No WiFi configuration found' });
    }

    await updatePrivateConfig({
      wifiClientSettings: {
        ssid: wifiConfig.ssid,
        password: wifiConfig.password,
        enabled: enabled,
        security: wifiConfig.security,
        freq: wifiConfig.freq,
      },
    });

    res.json({
      message: `WiFi client ${enabled ? 'enabled' : 'disabled'} successfully`,
    });
  } catch (error) {
    console.error('Error toggling WiFi client:', error);
    return res.status(500).json({ error: 'Failed to toggle WiFi client' });
  }
});

router.get('/status', async (req, res) => {
  const status = await getWifiClientStatus();
  res.json({ wifiClientStatus: status });
});

router.get('/scan', async (req, res) => {
  res.json({ networks: await scanForWifiNetworks() });
});

router.get('/reset', async (req, res) => {
  try {
    const wifiConfig = await getPrivateConfig(WIFI_CLIENT_SETTINGS_KEY);

    if (
      !wifiConfig ||
      !wifiConfig.ssid ||
      !wifiConfig.security ||
      !wifiConfig.enabled
    ) {
      return res.status(400).json({ error: 'SSID and password are required' });
    }
    console.log('Calling reset wifi client from /reset');
    await wifiClientManager.resetWifiClient(
      wifiConfig.ssid,
      wifiConfig.password,
      wifiConfig.security,
      wifiConfig.freq,
      true, // Force reset to ensure the client is reconfigured
    );
    res.json({ message: 'WiFi client reset successfully' });
  } catch (error) {
    console.error('Error resetting WiFi client:', error);
    res.status(500).json({ error: 'Failed to reset WiFi client' });
  }
});

export default router;