#include "channelmanager.h"

ChannelManager *ChannelManager::m_instance = nullptr;

ChannelManager::ChannelManager(QObject *parent) : QObject(parent)
{
  initializeChannelCapabilities();

  // Initialize all channels as available
  for (int i = INPUT_CHANNEL_1; i <= OUTPUT_CHANNEL_2; ++i)
  {
    ChannelId channelId = static_cast<ChannelId>(i);
    ChannelStatus status;
    status.occupied = false;
    status.operationDetails.operation = NONE;
    status.operationDetails.description = QString();
    status.operationDetails.connectionType = TWO_WIRE;
    m_channelStatus[channelId] = status;
  }
}

ChannelManager *ChannelManager::instance()
{
  if (!m_instance)
  {
    m_instance = new ChannelManager();
  }
  return m_instance;
}

void ChannelManager::initializeChannelCapabilities()
{
  // 输入通道1: 支持最多四线连接（白-红-灰-黑），可进行所有测量功能
  ChannelCapability inputCh1;
  inputCh1.type = INPUT_CHANNEL;
  inputCh1.maxWires = 4;
  inputCh1.wireColors = QStringList() << "白" << "红" << "灰" << "黑";
  inputCh1.supportedConnections = QList<ConnectionType>()
                                  << TWO_WIRE << THREE_WIRE << FOUR_WIRE;
  inputCh1.supportedOperations = QList<OperationType>()
                                 << VOLTAGE_MEASUREMENT << MV_MEASUREMENT
                                 << MA_MEASUREMENT << AC_MEASUREMENT
                                 << RESISTANCE_MEASUREMENT << FREQUENCY_MEASUREMENT
                                 << SWITCH_MEASUREMENT << INSULATION_MEASUREMENT;
  m_channelCapabilities[INPUT_CHANNEL_1] = inputCh1;

  // 输入通道2: 支持最多两线连接（白-灰），仅支持二线制测量
  ChannelCapability inputCh2;
  inputCh2.type = INPUT_CHANNEL;
  inputCh2.maxWires = 2;
  inputCh2.wireColors = QStringList() << "白" << "灰";
  inputCh2.supportedConnections = QList<ConnectionType>() << TWO_WIRE;
  inputCh2.supportedOperations = QList<OperationType>()
                                 << VOLTAGE_MEASUREMENT << MV_MEASUREMENT
                                 << MA_MEASUREMENT << AC_MEASUREMENT
                                 << RESISTANCE_MEASUREMENT << FREQUENCY_MEASUREMENT
                                 << SWITCH_MEASUREMENT;
  m_channelCapabilities[INPUT_CHANNEL_2] = inputCh2;

  // 输出通道1: 支持最多四线连接（用于电阻模拟）
  ChannelCapability outputCh1;
  outputCh1.type = OUTPUT_CHANNEL;
  outputCh1.maxWires = 4;
  outputCh1.wireColors = QStringList() << "白" << "红" << "灰" << "黑";
  outputCh1.supportedConnections = QList<ConnectionType>()
                                   << TWO_WIRE << THREE_WIRE << FOUR_WIRE;
  outputCh1.supportedOperations = QList<OperationType>()
                                  << VOLTAGE_OUTPUT << MV_OUTPUT << MA_OUTPUT
                                  << WAVEFORM_OUTPUT << RESISTANCE_SIMULATION;
  m_channelCapabilities[OUTPUT_CHANNEL_1] = outputCh1;

  // 输出通道2: 支持两线连接
  ChannelCapability outputCh2;
  outputCh2.type = OUTPUT_CHANNEL;
  outputCh2.maxWires = 2;
  outputCh2.wireColors = QStringList() << "白" << "灰";
  outputCh2.supportedConnections = QList<ConnectionType>() << TWO_WIRE;
  outputCh2.supportedOperations = QList<OperationType>()
                                  << VOLTAGE_OUTPUT << MV_OUTPUT << MA_OUTPUT
                                  << WAVEFORM_OUTPUT;
  m_channelCapabilities[OUTPUT_CHANNEL_2] = outputCh2;
}

bool ChannelManager::isChannelAvailable(ChannelId channel) const
{
  return !m_channelStatus.value(channel).occupied;
}

bool ChannelManager::canChannelSupport(ChannelId channel, OperationType operation,
                                       ConnectionType connection) const
{
  if (!m_channelCapabilities.contains(channel))
  {
    return false;
  }

  const ChannelCapability &capability = m_channelCapabilities[channel];

  // 检查连接类型支持
  if (!capability.supportedConnections.contains(connection))
  {
    return false;
  }

  // 检查操作类型支持
  if (operation != NONE && !capability.supportedOperations.contains(operation))
  {
    return false;
  }

  // 检查操作类型与通道类型的匹配
  if (isInputChannelOperation(operation))
  {
    return capability.type == INPUT_CHANNEL;
  }
  else if (isOutputChannelOperation(operation))
  {
    return capability.type == OUTPUT_CHANNEL;
  }
  else if (operation == NONE)
  {
    return true;
  }

  return false;
}

bool ChannelManager::occupyChannel(ChannelId channel, OperationType operation,
                                   const QString &description,
                                   ConnectionType connectionType)
{
  if (!isChannelAvailable(channel))
  {
    return false;
  }

  if (!canChannelSupport(channel, operation, connectionType))
  {
    return false;
  }

  ChannelStatus &status = m_channelStatus[channel];
  status.occupied = true;
  status.operationDetails.operation = operation;
  status.operationDetails.description = description;
  status.operationDetails.connectionType = connectionType;
  status.occupiedTime = QDateTime::currentDateTime();

  emit channelStatusChanged(channel, operation, description);
  return true;
}

void ChannelManager::releaseChannel(ChannelId channel)
{
  if (m_channelStatus.contains(channel))
  {
    ChannelStatus &status = m_channelStatus[channel];
    status.occupied = false;
    status.operationDetails.operation = NONE;
    status.operationDetails.description.clear();
    status.operationDetails.connectionType = TWO_WIRE;
    status.occupiedTime = QDateTime();

    emit channelReleased(channel);
    emit channelStatusChanged(channel, NONE, QString());
  }
}

ChannelManager::OperationType ChannelManager::getChannelOperation(ChannelId channel) const
{
  return m_channelStatus.value(channel).operationDetails.operation;
}

QString ChannelManager::getChannelDescription(ChannelId channel) const
{
  return m_channelStatus.value(channel).operationDetails.description;
}

ChannelManager::OperationDetails
ChannelManager::getChannelOperationDetails(ChannelId channel) const
{
  return m_channelStatus.value(channel).operationDetails;
}

QList<ChannelManager::OperationType>
ChannelManager::getSupportedOperations(ChannelId channel) const
{
  return m_channelCapabilities.value(channel).supportedOperations;
}

ChannelManager::ChannelCapability
ChannelManager::getChannelCapability(ChannelId channel) const
{
  return m_channelCapabilities.value(channel);
}

QList<ChannelManager::ChannelId>
ChannelManager::getAvailableChannels(ChannelType type) const
{
  QList<ChannelId> availableChannels;

  for (auto it = m_channelCapabilities.constBegin();
       it != m_channelCapabilities.constEnd(); ++it)
  {
    if (it.value().type == type && isChannelAvailable(it.key()))
    {
      availableChannels.append(it.key());
    }
  }

  return availableChannels;
}

QString ChannelManager::getOperationDisplayName(OperationType operation) const
{
  switch (operation)
  {
  case NONE:
    return "空闲";
  // 输入通道操作
  case VOLTAGE_MEASUREMENT:
    return "电压测量";
  case MV_MEASUREMENT:
    return "mV测量";
  case MA_MEASUREMENT:
    return "mA测量";
  case AC_MEASUREMENT:
    return "交流测量";
  case RESISTANCE_MEASUREMENT:
    return "电阻测量";
  case FREQUENCY_MEASUREMENT:
    return "频率测量";
  case SWITCH_MEASUREMENT:
    return "开关量测量";
  case INSULATION_MEASUREMENT:
    return "绝缘电阻测量";
  // 输出通道操作
  case VOLTAGE_OUTPUT:
    return "电压输出";
  case MV_OUTPUT:
    return "mV输出";
  case MA_OUTPUT:
    return "mA输出";
  case WAVEFORM_OUTPUT:
    return "波形输出";
  case RESISTANCE_SIMULATION:
    return "电阻模拟";
  }
  return "未知";
}

QString ChannelManager::getConnectionTypeDisplayName(ConnectionType connection) const
{
  switch (connection)
  {
  case TWO_WIRE:
    return "二线制";
  case THREE_WIRE:
    return "三线制";
  case FOUR_WIRE:
    return "四线制";
  }
  return "未知";
}

QString ChannelManager::getDetailedOperationDescription(
    const OperationDetails &details) const
{
  QString baseDescription = getOperationDisplayName(details.operation);

  if (details.operation == RESISTANCE_MEASUREMENT ||
      details.operation == RESISTANCE_SIMULATION)
  {
    baseDescription +=
        QString("(%1)").arg(getConnectionTypeDisplayName(details.connectionType));
  }

  if (!details.description.isEmpty())
  {
    baseDescription += QString(" - %1").arg(details.description);
  }

  return baseDescription;
}

bool ChannelManager::isInputChannelOperation(OperationType operation) const
{
  switch (operation)
  {
  case VOLTAGE_MEASUREMENT:
  case MV_MEASUREMENT:
  case MA_MEASUREMENT:
  case AC_MEASUREMENT:
  case RESISTANCE_MEASUREMENT:
  case FREQUENCY_MEASUREMENT:
  case SWITCH_MEASUREMENT:
  case INSULATION_MEASUREMENT:
    return true;
  default:
    return false;
  }
}

bool ChannelManager::isOutputChannelOperation(OperationType operation) const
{
  switch (operation)
  {
  case VOLTAGE_OUTPUT:
  case MV_OUTPUT:
  case MA_OUTPUT:
  case WAVEFORM_OUTPUT:
  case RESISTANCE_SIMULATION:
    return true;
  default:
    return false;
  }
}

QString ChannelManager::getChannelDisplayName(ChannelId channel) const
{
  switch (channel)
  {
  case INPUT_CHANNEL_1:
    return "输入通道1";
  case INPUT_CHANNEL_2:
    return "输入通道2";
  case OUTPUT_CHANNEL_1:
    return "输出通道1";
  case OUTPUT_CHANNEL_2:
    return "输出通道2";
  }
  return "未知通道";
}

QList<ChannelManager::ChannelId>
ChannelManager::getChannelsWithOperation(OperationType operation) const
{
  QList<ChannelId> channels;

  for (auto it = m_channelStatus.constBegin(); it != m_channelStatus.constEnd(); ++it)
  {
    if (it.value().operationDetails.operation == operation)
    {
      channels.append(it.key());
    }
  }

  return channels;
}