#include <Uefi.h>
#include <PiPei.h>

void *CopyMem(char *dst, char *src, unsigned int count)
{
  unsigned int count_1;
  char         *dst_1;
  char         *src_1;

  count_1 = count;
  if (src < dst && &src[count - 1] >= dst) {
    src_1 = &src[count - 1];
    dst_1 = &dst[count - 1];
  } else {
    count_1 = count & 3;
    qmemcpy(dst, src, 4 * (count >> 2));
    src_1 = &src[4 * (count >> 2)];
    dst_1 = &dst[4 * (count >> 2)];
  }

  qmemcpy(dst_1, src_1, count_1);
  return dst;
}

void *SetMem(void *buf, unsigned int count, char value)
{
  memset(buf, value, count);
  return buf;
}

int InitializeSmmTableEntries(int TableBase, int EntryCount, int FirstValue, int SecondValue)
{
  do {
    *(_DWORD *)(TableBase + 8 * EntryCount - 8) = FirstValue;
    *(_DWORD *)(TableBase + 8 * EntryCount-- - 4) = SecondValue;
  } while (EntryCount);

  return TableBase;
}

void *SetMem32(void *buf, unsigned int count, int value)
{
  memset32(buf, value, count);
  return buf;
}

EFI_STATUS ModuleEntryPoint(EFI_HANDLE ImageHandle, EFI_SYSTEM_TABLE *SystemTable)
{
  return PiSmmCommunicationPeiModuleEntryPoint();
}

int LocateSmmCommunicationEntry(void)
{
  _DWORD      *PeiServices;
  _DWORD      *SmmConfigurationTable;
  unsigned int NumberOfEntries;
  int          EntryBase;
  int          MatchCount;
  int          EntryIndex;
  int          EntryOffset;
  unsigned int TableEntryCount;
  int          CurrentMatch;
  int          TableCursor;

  SmmConfigurationTable = PeiServices;
  if (0) {
    DebugPrint(64, "LocateSmmCommunicationEntry - SmmConfigurationTable: %x\n", PeiServices[23]);
    DebugPrint(64, "LocateSmmCommunicationEntry - NumberOfTableEntries: %x\n", SmmConfigurationTable[22]);
    TableEntryCount = SmmConfigurationTable[22];
    EntryBase = PeiServices[23];
    CurrentMatch = 0;
    if (TableEntryCount) {
      for (TableCursor = EntryBase; !CompareGuid(TableCursor, (int)&unk_FFE337C0); TableCursor += 20) {
        if (++CurrentMatch >= TableEntryCount)
          return 0;
      }
      EntryOffset = 20 * CurrentMatch;
      return *(_DWORD *)(EntryOffset + EntryBase + 16);
    }
    return 0;
  }

  DebugPrint(64, "LocateSmmCommunicationEntry - SmmConfigurationTable: %x\n", PeiServices[40]);
  DebugPrint(64, "LocateSmmCommunicationEntry - NumberOfTableEntries: %x\n", SmmConfigurationTable[38]);
  NumberOfEntries = SmmConfigurationTable[38];
  EntryBase = PeiServices[40];
  MatchCount = 0;
  if (!NumberOfEntries)
    return 0;
  for (EntryIndex = EntryBase; !CompareGuid(EntryIndex, (int)&unk_FFE337C0); EntryIndex += 24) {
    if (++MatchCount >= NumberOfEntries)
      return 0;
  }
  EntryOffset = 24 * MatchCount;
  return *(_DWORD *)(EntryOffset + EntryBase + 16);
}

char *InitializeSmmCommunicationContext(void)
{
  _WORD *GuidHob;
  int    AssertHandler;
  int   *SmmS3ResumeState;
  void  *Hob;
  char  *SourceBuffer;
  int    AssertHandler2;
  char  *DestinationBuffer;
  int    AssertHandler3;

  GuidHob = GetFirstGuidHob(&unk_FFE337A0);
  if (!GuidHob) {
    AssertHandler = GetAssertHandler();
    if (AssertHandler)
      (*(void (**)(const char *, int, const char *))(AssertHandler + 4))(
        "e:\\hs\\UefiCpuPkg\\PiSmmCommunication\\PiSmmCommunicationPei.c",
        250,
        "GuidHob != ((void *) 0)");
  }
  SmmS3ResumeState = (int *)*((_DWORD *)GuidHob + 8);
  DebugPrint(64, "InitializeSmmCommunicationContext - SmmS3ResumeState: %x\n", SmmS3ResumeState);
  DebugPrint(64, "InitializeSmmCommunicationContext - Smst: %x\n", *(int *)((char *)SmmS3ResumeState + 90));
  SourceBuffer = (char *)GetGuidHobData(*SmmS3ResumeState, SmmS3ResumeState[1]);
  if (!SourceBuffer) {
    AssertHandler2 = GetAssertHandler();
    if (AssertHandler2)
      (*(void (**)(const char *, int, const char *))(AssertHandler2 + 4))(
        "e:\\hs\\UefiCpuPkg\\PiSmmCommunication\\PiSmmCommunicationPei.c",
        262,
        "SmmCommunicationContext != ((void *) 0)");
  }
  DestinationBuffer = (char *)GetCommunicationContextHob(Hob);
  if (!DestinationBuffer) {
    AssertHandler3 = GetAssertHandler();
    if (AssertHandler3)
      (*(void (**)(const char *, int, const char *))(AssertHandler3 + 4))(
        "e:\\hs\\UefiCpuPkg\\PiSmmCommunication\\PiSmmCommunicationPei.c",
        180,
        "Hob.Raw");
  }
  return CopyMem(DestinationBuffer, SourceBuffer, 0x10u);
}

EFI_STATUS PiSmmCommunicationPeiCommunicate(int a1, int a2)
{
  int     v3;
  int     v4;
  _WORD  *v5;
  int     v6;
  _DWORD  *v7;
  int     v8;
  int     v9;
  int     v10;
  _DWORD  *v11;
  int   (**SmmCommunication2Protocol)(int, _DWORD, _BYTE *, int *, _DWORD, _DWORD);
  char    SmmCommunicationBufferState;
  int   (**SmmCommunicationProtocol)(int, _DWORD, char *, int *, _DWORD, _DWORD);
  int     LockState;
  int     CommunicateResult;

  DebugPrint(64, "PiSmmCommunicationPei Communicate Enter\n");
  if (!a2)
    return -2147483646;
  v3 = GetPeiServicesTable();
  if ((*(int (**)(int, void *, _DWORD, _DWORD, int (***)(int, _DWORD, char *, int *, _DWORD, _DWORD)))(*(_DWORD *)v3 + 32))(
        v3, &unk_FFE337B0, 0, 0, &SmmCommunicationProtocol) < 0)
    return -2147483629;
  v4 = GetPeiServicesTable();
  if ((*(int (**)(int, void *, _DWORD, _DWORD, int *))(*(_DWORD *)v4 + 32))(v4, &unk_FFE33780, 0, 0, &LockState) < 0)
    return -2147483629;
  if (!*(_BYTE *)(LockState + 16)) {
    DebugPrint(64, "PiSmmCommunicationPei LockState - %x\n", 0);
    return -2147483629;
  }
  v5 = GetFirstGuidHob(&unk_FFE337C0);
  if (!v5) {
    v6 = GetAssertHandler();
    if (v6)
      (*(void (**)(const char *, int, const char *))(v6 + 4))(
        "e:\\hs\\UefiCpuPkg\\PiSmmCommunication\\PiSmmCommunicationPei.c",
        155,
        "GuidHob != ((void *) 0)");
  }
  DebugPrint(
    64,
    "PiSmmCommunicationPei BufferPtrAddress - 0x%016lx, BufferPtr: 0x%016lx\n",
    *((_DWORD *)v5 + 8),
    *((_DWORD *)v5 + 9));
  v7 = (_DWORD *)*((_DWORD *)v5 + 8);
  *v7 = a2;
  v7[1] = 0;
  DebugPrint(64, "PiSmmCommunicationPei CommBuffer - %x\n", a2);
  SmmCommunicationBufferState = *((_BYTE *)v5 + 28);
  CommunicateResult = 1;
  SmmCommunication2Protocol = SmmCommunicationProtocol;
  v8 = GetPeiServicesTable();
  v9 = (*SmmCommunicationProtocol)(v8, SmmCommunication2Protocol, &SmmCommunicationBufferState, &CommunicateResult, 0, 0);
  if (v9 < 0) {
    DebugPrint(0x80000000, "\nASSERT_EFI_ERROR (Status = %r)\n", v9);
    v10 = GetAssertHandler();
    if (v10)
      (*(void (**)(const char *, int, const char *))(v10 + 4))(
        "e:\\hs\\UefiCpuPkg\\PiSmmCommunication\\PiSmmCommunicationPei.c",
        357,
        "!EFI_ERROR (Status)");
  }
  v11 = (_DWORD *)*((_DWORD *)v5 + 8);
  *v11 = 0;
  v11[1] = 0;
  DebugPrint(64, "PiSmmCommunicationPei Communicate Exit\n");
  return 0;
}

EFI_STATUS PiSmmCommunicationPeiModuleEntryPoint(void)
{
  int    v0;
  int    v1;
  int    v2;
  int    v4;
  int    v5;
  int    v6;
  unsigned __int8 v7;
  int    v8;
  int    v9;
  int    v10;
  int    v11;
  int    n17;
  int    v13;

  v0 = GetPeiServicesTable();
  v1 = (*(int (**)(int, int *))(*(_DWORD *)v0 + 40))(v0, &n17);
  if (v1 < 0) {
    DebugPrint(0x80000000, "\nASSERT_EFI_ERROR (Status = %r)\n", v1);
    v2 = GetAssertHandler();
    if (v2)
      (*(void (**)(const char *, int, const char *))(v2 + 4))(
        "e:\\hs\\MdePkg\\Library\\PeiHobLib\\HobLib.c",
        216,
        "!EFI_ERROR (Status)");
  }
  if (n17 != 17)
    return -2147483645;
  v4 = GetPeiServicesTable();
  v5 = 0;
  if ((*(int (**)(int, void *, _DWORD, _DWORD, int *))(*(_DWORD *)v4 + 32))(v4, &unk_FFE33780, 0, 0, &v13) < 0)
    return -2147483629;
  v6 = v13;
  v7 = *(_BYTE *)(v13 + 16);
  if (v7) {
    DebugPrint(64, "PiSmmCommunicationPei LockState - %x\n", v7);
    return -2147483633;
  }
  while (1) {
    v11 = v6;
    v8 = GetPeiServicesTable();
    v9 = (*(int (**)(int, int, int))v13)(v8, v11, v5++);
    if (v9 < 0)
      break;
    v6 = v13;
  }
  InitializeSmmCommunicationContext();
  v10 = GetPeiServicesTable();
  (*(void (**)(int, void *))(*(_DWORD *)v10 + 24))(v10, &unk_FFE337D0);
  return 0;
}