/**
 * ServerMgmtSetup.c - Server Management Setup Module
 *
 * UEFI HII driver for Lenovo server management configuration.
 * Provides BIOS setup forms for BMC LAN, DNS, NCSI, FRU, SOL,
 * IPMI user management, and SEL viewing.
 *
 * Source: AMI IPMI Framework (AmiIpmiPkg)
 * Platform: Lenovo HR650X (Neon City)
 */

#include "ServerMgmtSetup.h"

//
// Global State
//
EFI_HANDLE                  gImageHandle       = NULL;
EFI_SYSTEM_TABLE           *gSystemTable       = NULL;
EFI_BOOT_SERVICES          *gBootServices      = NULL;
EFI_RUNTIME_SERVICES       *gRuntimeServices   = NULL;
EFI_HII_DATABASE_PROTOCOL  *gHiiDatabase       = NULL;
EFI_HII_STRING_PROTOCOL    *gHiiString         = NULL;
EFI_HII_CONFIG_ROUTING_PROTOCOL *gHiiConfigRouting = NULL;
VOID                       *gHiiConfigAccess   = NULL;
VOID                       *gFormBrowser2      = NULL;
VOID                       *gIpmiTransport     = NULL;
EFI_HANDLE                  gImageHandleRaw    = NULL;
EFI_SYSTEM_TABLE           *gST                = NULL;
EFI_BOOT_SERVICES          *gBS                = NULL;
EFI_RUNTIME_SERVICES       *gRT                = NULL;
VOID                       *gDxeIpmiTransport  = NULL;
VOID                       *gHiiConfigRouting2 = NULL;
UINT8                       gSelDelInitDone    = 0;
UINT64                      gCurrentFormContext = 0;
UINT8                       gBmcMaxUsers       = 0;
UINT8                       gBmcLanKey         = 0;
UINT8                       gBmcUserCount      = 0;

extern HII_CALLBACK_ENTRY mCallbackTable[];

/**
 * _ModuleEntryPoint - UEFI module entry point
 */
EFI_STATUS
EFIAPI
ModuleEntryPoint (
  IN EFI_HANDLE        ImageHandle,
  IN EFI_SYSTEM_TABLE *SystemTable
  )
{
  UefiBootServicesTableLibConstructor();
  return ServerMgmtSetupEntry(ImageHandle, SystemTable);
}

/**
 * UefiBootServicesTableLibConstructor - Initialize global service pointers
 */
VOID
UefiBootServicesTableLibConstructor (
  VOID
  )
{
  EFI_STATUS Status;

  gImageHandleRaw = ImageHandle;
  ASSERT(gImageHandleRaw != NULL);
  gST = SystemTable;
  ASSERT(gST != NULL);
  gBS = SystemTable->BootServices;
  ASSERT(gBS != NULL);
  gRT = SystemTable->RuntimeServices;
  ASSERT(gRT != NULL);

  Status = gBS->LocateProtocol(
    &gEfiHiiDatabaseProtocolGuid, NULL, (VOID**)&gHiiDatabase);
  ASSERT_EFI_ERROR(Status);

  Status = gBS->LocateProtocol(
    &gEfiHiiStringProtocolGuid, NULL, (VOID**)&gHiiString);
  ASSERT_EFI_ERROR(Status);

  Status = gBS->LocateProtocol(
    &gEfiHiiConfigRoutingProtocolGuid, NULL, (VOID**)&gHiiConfigRouting);
  ASSERT_EFI_ERROR(Status);

  gBS->LocateProtocol(&gEfiHiiConfigAccessProtocolGuid,  NULL, &gHiiConfigAccess);
  gBS->LocateProtocol(&gEfiFormBrowser2ProtocolGuid,     NULL, &gFormBrowser2);
  gBS->LocateProtocol(&gEfiDxeIpmiTransportProtocolGuid, NULL, &gIpmiTransport);
}

/**
 * ServerMgmtSetupEntry - Register HII form and install driver handle
 */
EFI_STATUS
EFIAPI
ServerMgmtSetupEntry (
  IN EFI_HANDLE        ImageHandle,
  IN EFI_SYSTEM_TABLE *SystemTable
  )
{
  EFI_HII_HANDLE  HiiHandle;
  EFI_HANDLE      DriverHandle;
  UINTN           BufferSize;
  EFI_STATUS      Status;

  if (gSystemTable == NULL) {
    gSystemTable = (UINTN)SystemTable;
    gBootServices = (UINTN)SystemTable->BootServices;
    gRuntimeServices = (UINTN)SystemTable->RuntimeServices;
  }
  gImageHandle = ImageHandle;

  BufferSize = sizeof(mServerSetupFormData);
  Status = gRT->GetVariable(
    L"ServerSetup", &mServerSetupFormGuid,
    NULL, &BufferSize, &mServerSetupFormData);

  if (Status == EFI_NOT_FOUND) {
    HiiInitDelayed(0, 0);
    Status = gBS->InstallProtocolInterface(
      &DriverHandle, &gEfiHiiConfigAccessProtocolGuid,
      EFI_NATIVE_INTERFACE, &mConfigAccessProtocol);
    if (Status >= 0) {
      gBS->InstallProtocolInterface(
        (UINT32*)GuidData,
        EFI_NATIVE_INTERFACE,
        &mConfigAccessProtocol);
    }
  } else {
    HiiInitDelayed(0, 0);
  }
  return EFI_SUCCESS;
}

/**
 * HiiCallbackRouter - Route HII callbacks to form/question handlers
 */
EFI_STATUS
EFIAPI
HiiCallbackRouter (
  IN     CONST EFI_HII_CONFIG_ACCESS_PROTOCOL *This,
  IN     EFI_BROWSER_ACTION                   Action,
  IN     EFI_QUESTION_ID                      QuestionId,
  IN     EFI_FORM_ID                          FormId,
  IN     VOID                                 *CallbackData,
  OUT    EFI_BROWSER_ACTION_REQUEST           *HandleResult
  )
{
  HII_CALLBACK_ENTRY *Entry;
  EFI_STATUS          Status;

  gCurrentFormContext = (UINTN)&Action;
  Status = EFI_UNSUPPORTED;

  if (mCallbackTable != NULL) {
    Entry = &mCallbackTable[0];
    while (Entry->Handler != NULL) {
      if (Entry->FormId == FormId && Entry->QuestionId == QuestionId) {
        Status = Entry->Handler(
          (EFI_HANDLE)gHiiConfigAccess,
          Action, QuestionId, FormId,
          CallbackData, HandleResult);
        if (Status != EFI_UNSUPPORTED) break;
      }
      Entry++;
    }
  }
  gCurrentFormContext = 0;
  return Status;
}

/**
 * HiiInitDelayed - Locate HII protocols and initialize SEL deletion support
 */
VOID
HiiInitDelayed (
  IN EFI_HANDLE ImageHandle OPTIONAL
  )
{
  if (gHiiDatabase == NULL)
    gBS->LocateProtocol(&gEfiHiiDatabaseProtocolGuid, NULL, (VOID**)&gHiiDatabase);
  if (gHiiString == NULL)
    gBS->LocateProtocol(&gEfiHiiStringProtocolGuid, NULL, (VOID**)&gHiiString);

  if ((gHiiDatabase != NULL) && (gHiiString != NULL)) {
    if (ImageHandle != NULL) gBS->FreePool(ImageHandle);
    if (!gSelDelInitDone) {
      gSelDelInitDone = TRUE;
      InitSelDelSupport();
    }
  }
}

/**
 * GetBmcLanConfiguration - Read BMC LAN configuration via IPMI
 */
EFI_STATUS
GetBmcLanConfiguration (
  OUT BMC_LAN_CONFIGURATION *LanConfigBuffer
  )
{
  return InternalIpmiSendCommand(
    IPMI_NETFN_APP | IPMI_LUN_0,
    IPMI_APP_GET_LAN_CONFIG,
    LanConfigBuffer, sizeof(*LanConfigBuffer));
}

/**
 * SetBmcLanConfiguration - Write BMC LAN configuration via IPMI
 */
EFI_STATUS
SetBmcLanConfiguration (
  IN BMC_LAN_CONFIGURATION *LanConfigBuffer
  )
{
  return InternalIpmiSendCommand(
    IPMI_NETFN_APP | IPMI_LUN_0,
    IPMI_APP_SET_LAN_CONFIG,
    LanConfigBuffer, sizeof(*LanConfigBuffer));
}

/**
 * SetBmcLanInterfaceState - Set BMC LAN interface state via IPMI
 */
EFI_STATUS
SetBmcLanInterfaceState (
  IN BOOLEAN Enable
  )
{
  UINT8 Command[2];
  Command[0] = IPMI_LAN_SET_INTERFACE_ENABLE;
  Command[1] = Enable ? 1 : 0;
  return InternalIpmiSendCommand(
    IPMI_NETFN_TRANSPORT | IPMI_LUN_0,
    IPMI_TRANSPORT_SET_LAN_CONFIG,
    Command, sizeof(Command));
}

/**
 * GetBmcDnsConfiguration - Retrieve DNS configuration from BMC
 */
EFI_STATUS
GetBmcDnsConfiguration (
  OUT BMC_DNS_CONFIGURATION *DnsConfigBuffer
  )
{
  return InternalIpmiSendCommand(
    IPMI_NETFN_TRANSPORT | IPMI_LUN_0,
    IPMI_TRANSPORT_GET_DNS_CONFIG,
    DnsConfigBuffer, sizeof(*DnsConfigBuffer));
}

/**
 * SetBmcDnsConfiguration - Configure BMC DNS via IPMI
 */
EFI_STATUS
SetBmcDnsConfiguration (
  IN BMC_DNS_CONFIGURATION *DnsConfigBuffer
  )
{
  return InternalIpmiSendCommand(
    IPMI_NETFN_TRANSPORT | IPMI_LUN_0,
    IPMI_TRANSPORT_SET_DNS_CONFIG,
    DnsConfigBuffer, sizeof(*DnsConfigBuffer));
}

/**
 * SendBmcCommand - Generic BMC IPMI command send/receive
 */
EFI_STATUS
SendBmcCommand (
  IN  UINT8   NetFn,
  IN  UINT8   Command,
  IN  UINT8   *RequestData,
  IN  UINT32  RequestSize,
  OUT UINT8   *ResponseData,
  IN  OUT UINT32 *ResponseSize
  )
{
  return InternalProcessBmcCommand(
    NetFn, Command,
    RequestData, RequestSize,
    ResponseData, ResponseSize);
}

/**
 * UpdateHiiString - Write a string value to the HII form
 */
VOID
UpdateHiiString (
  IN EFI_FORM_ID FormId,
  IN EFI_STRING_ID StringId
  )
{
  gHiiConfigRouting2->UpdateString(
    gHiiConfigRouting2, 0, FormId, StringId, L"Setup");
}

/**
 * ZeroMemoryBios - Clear a memory buffer
 */
VOID
ZeroMemoryBios (
  IN VOID   *Buffer,
  IN UINTN  Size
  )
{
  UINT8 *Ptr = (UINT8 *)Buffer;
  while (Size--) *Ptr++ = 0;
}

/**
 * SetNcsiSwitchCmd - Send NCSI switch IPMI command to BMC
 */
EFI_STATUS
SetNcsiSwitchCmd (
  IN UINT8 Selector
  )
{
  UINT8 NcsiCommand[8];
  NcsiCommand[0] = 0;
  NcsiCommand[1] = 0x01;
  NcsiCommand[2] = Selector;
  return InternalIpmiSendCommand(
    IPMI_NETFN_OEM | IPMI_LUN_0,
    IPMI_OEM_NCSI_SWITCH,
    NcsiCommand, sizeof(NcsiCommand));
}

/**
 * BmcDnsConfigCallback - BMC DNS configuration handler (10004)
 */
EFI_STATUS
BmcDnsConfigCallback (
  IN UINT64    a1,
  IN UINT64    a2,
  IN UINT64    a3,
  IN UINT16    a4
  )
{
  UINT8   DnsBuffer[581];
  UINT8   Ipv6Buffer[581];
  UINTN   bufferSize;
  UINT32  IpAddressParts;
  CHAR8   IpStr[32];

  ZeroMem(DnsBuffer, sizeof(DnsBuffer));
  ZeroMem(Ipv6Buffer, sizeof(Ipv6Buffer));
  bufferSize = sizeof(DnsBuffer);

  if ((a4 - 10006) > 2) return EFI_INVALID_PARAMETER;

  if (gCurrentFormContext + 8 != 1) {
    LoadFormData(&bufferSize, DnsBuffer,
      SETUP_DATA_GUID, L"SetupBmcDnsConfig");

    switch (a4) {
      case 0x2716: case 0x2717: case 0x2718:
        ValidateAndStoreIpAddress(IpBuffer1, IpResult, &IpAddressParts);
        CopyIpAddressOctets(IpResult, (UINT8 *)&IpAddressParts, 4);
        FormatIpDisplayString(IpBuffer2, L"%d.%d.%d.%d", ...);
        break;
    }

    if (CheckHexStringInput(IpBuffer1, IpResult, &IpAddressParts) >= 0
        && *(UINT16 *)IpResult == 0) {
      ValidateIpOctets();
    }

    SaveFormData(bufferSize, DnsBuffer,
      SETUP_DATA_GUID, L"SetupBmcDnsConfig");
  }
  return EFI_SUCCESS;
}

/**
 * AddNewBmcUserCb - Add a new BMC user via IPMI (Callback 10063)
 */
EFI_STATUS
AddNewBmcUserCb (
  IN UINT64    a1,
  IN UINT64    a2,
  IN UINT64    a3,
  IN UINT16    ActionId
  )
{
  UINT8   NewUserId;
  CHAR8   UserName[17];
  UINT8   Buffer[892];
  UINT8   PasswordHash[18];
  UINT8   StateBuffer[180];

  ZeroMem(Buffer, sizeof(Buffer));

  if (ActionId != 10063) return EFI_INVALID_PARAMETER;
  if (gCurrentFormContext + 8 != 1) return EFI_SUCCESS;

  *(UINT64 *)(Buffer + 2) = 0x10000;
  *(UINT32 *)Buffer = 0x140012;
  *(UINT64 *)(Buffer + 16) = (UINT64)(Buffer + 72);

  gHiiConfigRouting2->SetString(Buffer + 32, 360, ...);

  WideStrToMultiByte(gBmcNewUserBuffer, gBmcUserNameBuffer);
  if (StrLen(gBmcUserNameBuffer) == 0 || StrLen(gBmcUserNameBuffer) > 20) {
    UpdateHiiString(394);
    ZeroBuffer(gBmcNewUserBuffer, 21);
    return EFI_INVALID_PARAMETER;
  }

  gBmcLanKey = GetLanKey();
  if (SendIpmiCommand(3, gBmcNewUserBuffer) >= 0) {
    for (Index = 0; Index < gBmcMaxUsers; Index++) {
      if (CheckUserNameExists(gBmcUserNameList[Index],
                              gBmcUserNameTemp)) break;
    }
    if (Index < gBmcMaxUsers) {
      EncodePassword();
      SendBmcAddUser();
      UpdateHiiString(397);
      ClearBuffer(gBmcLanKey);
      ClearBuffer(PasswordBuffer);
      RefreshUserList(a1);
      return EFI_SUCCESS;
    }
  }
  UpdateHiiString(Index >= gBmcMaxUsers ? 396 : 395);
  return EFI_INVALID_PARAMETER;
}

/**
 * WideStrCmp - Wide string comparison
 */
BOOLEAN
WideStrCmp (
  IN CONST CHAR16 *Str1,
  IN CONST CHAR16 *Str2
  )
{
  while (*Str1 != L'\0' && *Str2 != L'\0') {
    if (*Str1 != *Str2) return FALSE;
    Str1++; Str2++;
  }
  return (*Str1 == L'\0' && *Str2 == L'\0');
}

/**
 * WideStrToMultiByte - Convert wide string to ASCII
 */
VOID
WideStrToMultiByte (
  IN  CONST CHAR16 *WideStr,
  OUT CHAR8        *MultiStr
  )
{
  while (*WideStr != L'\0') *MultiStr++ = (CHAR8)*WideStr++;
  *MultiStr = '\0';
}

/**
 * MultiByteToWideStr - Convert ASCII to wide string
 */
VOID
MultiByteToWideStr (
  IN  CONST CHAR8  *MultiStr,
  OUT CHAR16       *WideStr
  )
{
  while (*MultiStr != '\0') *WideStr++ = (CHAR16)*MultiStr++;
  *WideStr = L'\0';
}

/**
 * AmiConvertHexStringToInt - Parse hex string to integer
 */
EFI_STATUS
AmiConvertHexStringToInt (
  IN  CONST CHAR8   *HexStr,
  OUT UINT64        *Value,
  IN  UINTN         MaxLen
  )
{
  UINTN  Index;
  UINT64 Result = 0;

  for (Index = 0; Index < MaxLen && HexStr[Index] != '\0'; Index++) {
    if (!IsHexChar(HexStr[Index])) return EFI_INVALID_PARAMETER;
    Result = (Result << 4) | HexCharToInt(HexStr[Index]);
  }
  *Value = Result;
  return EFI_SUCCESS;
}

/**
 * IsHexChar - Check if character is valid hex digit
 */
BOOLEAN
IsHexChar (
  IN CHAR8 Char
  )
{
  return ((Char >= '0' && Char <= '9') ||
          (Char >= 'A' && Char <= 'F') ||
          (Char >= 'a' && Char <= 'f'));
}

/**
 * HexCharToInt - Convert hex character to integer value
 */
UINT8
HexCharToInt (
  IN CHAR8 Char
  )
{
  if (Char >= '0' && Char <= '9') return Char - '0';
  Char = ConvertToUppercase(Char);
  return Char - 'A' + 10;
}

/**
 * ConvertToUppercase - Convert ASCII char to uppercase
 */
CHAR8
ConvertToUppercase (
  IN CHAR8 Char
  )
{
  if (Char >= 'a' && Char <= 'z') return Char - ('a' - 'A');
  return Char;
}

/**
 * DebugPrintFormat - Debug serial print with format string
 */
VOID
DebugPrintFormat (
  IN UINTN        ErrorLevel,
  IN CONST CHAR8  *Format,
  ...
  )
{
  VA_LIST Marker;
  VA_START(Marker, Format);
  AsciiVSPrint(Format, Marker);
  VA_END(Marker);
}

/**
 * AssertDeadloop - ASSERT failure handler with deadloop
 */
VOID
AssertDeadloop (
  IN CONST CHAR8  *FileName,
  IN UINTN        LineNumber,
  IN CONST CHAR8  *Message
  )
{
  DEBUG((EFI_D_ERROR, "\nASSERT %a(%d): %a\n",
         FileName, (UINTN)LineNumber, Message));
  CpuDeadLoop();
}

/**
 * CopyIpAddressOctets - Copy IP address octets from 32-bit value
 */
VOID
CopyIpAddressOctets (
  OUT UINT8   *Dest,
  IN  UINT32  *Source,
  IN  UINTN   OctetCount
  )
{
  UINTN Index;
  for (Index = 0; Index < OctetCount; Index++)
    Dest[Index] = (UINT8)(*Source >> (Index * 8));
}

/**
 * StringLen - Get ASCII string length
 */
UINTN
StringLen (
  IN CONST CHAR8 *String
  )
{
  UINTN Length = 0;
  while (String[Length] != '\0') Length++;
  return Length;
}

/**
 * AsciiStrCmp - Compare two ASCII strings
 */
BOOLEAN
AsciiStrCmp (
  IN CONST CHAR8 *Str1,
  IN CONST CHAR8 *Str2
  )
{
  while (*Str1 != '\0' && *Str2 != '\0') {
    if (*Str1 != *Str2) return FALSE;
    Str1++; Str2++;
  }
  return (*Str1 == '\0' && *Str2 == '\0');
}

/**
 * IsNumericChar - Check if character is numeric
 */
BOOLEAN
IsNumericChar (
  IN CHAR8 Char
  )
{
  return (Char >= '0' && Char <= '9');
}

/**
 * ValidateHexString - Validate hex string format
 */
BOOLEAN
ValidateHexString (
  IN CONST CHAR8 *HexStr
  )
{
  while (*HexStr != '\0') {
    if (!IsHexChar(*HexStr)) return FALSE;
    HexStr++;
  }
  return TRUE;
}