#include <stdio.h>

#include <Uefi.h>
#include <Library/UefiLib.h>
#include <Library/UefiApplicationEntryPoint.h>
#include <Include/Guid/FileSystemInfo.h>


EFI_STATUS
EFIAPI
UefiMain (
  IN EFI_HANDLE        ImageHandle,
  IN EFI_SYSTEM_TABLE  *SystemTable
  )
{

  EFI_STATUS efiStatus;
  EFI_BOOT_SERVICES* bs = SystemTable->BootServices;
  EFI_GUID sfspGuid = EFI_SIMPLE_FILE_SYSTEM_PROTOCOL_GUID;

  EFI_HANDLE* handleBuffer = NULL;
  EFI_HANDLE* handleBuffer2 = NULL;   
  UINTN handleCount = 0;
  UINTN handleCount2 = 0;
  UINTN handleIndex;

  EFI_GUID **ProtocolGuidArray;
  UINTN ArrayCount;
  UINTN ProtocolIndex;

  EFI_OPEN_PROTOCOL_INFORMATION_ENTRY *OpenInfo;
  UINTN OpenInfoIndex;
  UINTN OpenInfoCount;

  efiStatus = bs->LocateHandleBuffer (
    AllHandles,
    NULL,
    NULL,
    &handleCount,
    &handleBuffer
  );

  UINT32 sfspData1 = sfspGuid.Data1;

  //Print(L"EFI_STATUS after LocateHandleBuffer: %r\n", efiStatus);
  //Print(L"Number of handles found: %d\n", handleCount); // Last time: 182

  if (!EFI_ERROR (efiStatus)) {
    for (handleIndex = 0; handleIndex < handleCount; handleIndex++) {
    	//
    	// Retrieve the list of all the protocols on each handle
    	//
		  efiStatus = bs->ProtocolsPerHandle (
		    handleBuffer[handleIndex],
		    &ProtocolGuidArray,
		    &ArrayCount
		  );

      //Print(L"EFI_STATUS after ProtocolsPerHandle: %r\n", efiStatus);
      //Print(L"Number of Protocols per Handle: %d\n", ArrayCount);

  		if (!EFI_ERROR (efiStatus)) {
			  for (ProtocolIndex = 0; ProtocolIndex < ArrayCount; ProtocolIndex++) {

          EFI_GUID *guid = ProtocolGuidArray[ProtocolIndex];
          UINT32 Data1;
          UINT16 Data2;
          UINT32 Data3;
          UINT8 Data4[8];
          Data1 = guid->Data1;
          Data2 = guid->Data2;
          Data3 = guid->Data3;
          for (int i = 0; i < 8; i++) {
            Data4[i] = guid->Data4[i];
          }

          // TODO compare the other values
          if (Data1 == sfspData1) {
            Print(L"GUID: %x-%x-%x-%x-%x-%x-%x-%x-%x-%x-%x\n", Data1, Data2, Data3, Data4[0], Data4[1], 
              Data4[2], Data4[3], Data4[4], Data4[5], Data4[6], Data4[7]);
            Print(L"handleIndex: %d\n", handleIndex);
            Print(L"ProtocolIndex: %d\n", ProtocolIndex);

		        //
				    // Retrieve the protocol instance for each protocol
				    //
				    efiStatus = bs->OpenProtocol (
				      handleBuffer[handleIndex],
				      ProtocolGuidArray[ProtocolIndex],
				      NULL,
				      ImageHandle,
				      NULL,
				      EFI_OPEN_PROTOCOL_GET_PROTOCOL
				    );

				    //
				    // Retrieve the list of agents that have opened each protocol
				    //
				    efiStatus = bs->OpenProtocolInformation (
				      handleBuffer[handleIndex],
				      ProtocolGuidArray[ProtocolIndex],
				      &OpenInfo,
				      &OpenInfoCount
				    );

            Print(L"Number of agents which have opened the protocol: %d\n", OpenInfoCount);

            EFI_SIMPLE_FILE_SYSTEM_PROTOCOL* fs = NULL;
   
            efiStatus = bs->HandleProtocol( // TODO Should use OpenProtocol() in new implementations
              handleBuffer[handleIndex],
              &sfspGuid,
              (void**)&fs
            );

            Print(L"Status after HandleProtocol: %r\n", efiStatus);
            Print(L"fs pointer: %p\n", fs);


            EFI_FILE_PROTOCOL* root = NULL;

            efiStatus = fs->OpenVolume(fs, &root);
            Print(L"Status after open volume: %r\n", efiStatus);

            EFI_GUID fsiGuid = EFI_FILE_SYSTEM_INFO_ID;
            
            UINTN bufSize = 0;
            
            EFI_FILE_SYSTEM_INFO* fileSystemInfo = NULL;
            efiStatus = root->GetInfo(
              root,
              &fsiGuid,
              &bufSize,
              &fileSystemInfo);

            Print(L"Status: %r\n", efiStatus);
            Print(L"Required buffer size: %d\n", bufSize );

            efiStatus = bs->AllocatePool(EfiLoaderData, (UINTN) (bufSize) , (void **)&fileSystemInfo);

            efiStatus = root->GetInfo(
              root,
              &fsiGuid,
              &bufSize,
              fileSystemInfo);

            Print(L"Status: %r\n", efiStatus);

            Print(L"fileSystemInfo pointer %p\n", fileSystemInfo);

            CHAR16* volumeLabel = fileSystemInfo->VolumeLabel;
            Print(L"VolumeLabel: %a\n", volumeLabel);
            Print(L"Size of volume Label: %d\n", sizeof(fileSystemInfo->VolumeLabel));
            Print(L"Size: %d\n", fileSystemInfo->Size);
            Print(L"ReadOnly: %d\n", fileSystemInfo->ReadOnly);
            Print(L"VolumeSize: %d\n", fileSystemInfo->VolumeSize);
            Print(L"FreeSpace: %d\n", fileSystemInfo->FreeSpace);
            Print(L"BlockSize: %d\n", fileSystemInfo->BlockSize);
/*
            efiStatus = bs->FreePool((void **)&buffer);
            Print(L"efiStatus after FreePool: %r\n", efiStatus);*/


            EFI_FILE_PROTOCOL* token = NULL;
            efiStatus = root->Open(
              root, 
              &token,
              L"log",
              EFI_FILE_MODE_READ | EFI_FILE_MODE_WRITE | EFI_FILE_MODE_CREATE,
              0);

            UINTN fileSize = 50; // TODO get the actual size
            CHAR16* fileBuffer = NULL;
            efiStatus = bs->AllocatePool(EfiLoaderData, (UINTN) (fileSize) , (void **)&fileBuffer);

            efiStatus = token->Read(token, &fileSize, fileBuffer);
            Print(L"Status after file read: %r\n", efiStatus);
            Print(L"File Size: %d\n", fileSize);
            Print(L"File Buffer Pointer: %p\n", fileBuffer);
            Print(L"File Content: %a\n", fileBuffer);

            UINT64 currPos;

            token->GetPosition(token, &currPos);
            Print(L"Current File Position: %d\n", currPos);

            fileBuffer[0] = (CHAR16) 'X';
            Print(L"New file Buffer: %a\n", fileBuffer);

            token->SetPosition(token, 0);

            efiStatus = token->Write(token, &fileSize, fileBuffer);

            Print(L"Status after file write: %r\n", efiStatus);


/*
          EFI_FILE_OPEN         Open;
  EFI_FILE_CLOSE        Close;
  EFI_FILE_DELETE       Delete;
  EFI_FILE_READ         Read;
  EFI_FILE_WRITE        Write;
  EFI_FILE_GET_POSITION GetPosition;
  EFI_FILE_SET_POSITION SetPosition;
  EFI_FILE_GET_INFO     GetInfo;
  EFI_FILE_SET_INFO     SetInfo;
  EFI_FILE_FLUSH        Flush;*/
          }
        }
      }

			if (!EFI_ERROR (efiStatus)) {
				for (OpenInfoIndex=0; OpenInfoIndex < OpenInfoCount; OpenInfoIndex++) {
						//
						// HandleBuffer[handleIndex] is the handle
						// ProtocolGuidArray[ProtocolIndex] is the protocol GUID
						// Instance is the protocol instance for the protocol
						// OpenInfo[OpenInfoIndex] is an agent that has opened a protocol
						//
				}
				/*if (OpenInfo != NULL) { // TODO Why is it crashing when using FreePool?
					bs->FreePool(OpenInfo);
          Print(L"EFI_STATUS after FreePool(OpenInfo): %r\n", efiStatus);
				}*/
 	 		}

  		/*if (ProtocolGuidArray != NULL) {
				bs->FreePool(ProtocolGuidArray);
        Print(L"EFI_STATUS after FreePool(ProtocolGuidArray): %r\n", efiStatus);
  		}*/
		}
		/*if (handleBuffer != NULL) {
		  efiStatus = bs->FreePool(handleBuffer);
      Print(L"EFI_STATUS after FreePool(handleBuffer): %r\n", efiStatus);
    }*/
  }
  Print(L"sfps: %x\n", sfspData1);

  efiStatus = bs->LocateHandleBuffer(ByProtocol, 
                                   &sfspGuid, 
                                   NULL, 
                                   &handleCount2, 
                                   &handleBuffer2);

  Print(L"Handle count: %d\n", handleCount2);


  return EFI_SUCCESS;
}