#include <Platform.h>
#include "../cpp_foundation/XString.h"
#include "../cpp_foundation/XStringArray.h"
#include "../cpp_foundation/XStringW.h"
#include "global_test.h"



CHAR16 *Old1_AddLoadOption(IN CONST CHAR16 *LoadOptions, IN CONST CHAR16 *LoadOption)
{
  // If either option strings are null nothing to do
  if (LoadOptions == NULL)
  {
    if (LoadOption == NULL) return NULL;
    // Duplicate original options as nothing to add
    return EfiStrDuplicate(LoadOption);
  }
  // If there is no option or it is already present duplicate original
  // with XStringW it will be replaced by if (LoadOptions.ExistIn(LoadOption))
  else if ((LoadOption == NULL) || StrStr(LoadOptions, LoadOption))
    return EfiStrDuplicate(LoadOptions);
  // Otherwise add option
//  return PoolPrint(L"%s %s", LoadOptions, LoadOption); //LoadOptions + LoadOption
  return SWPrintf("%ls %ls", LoadOptions, LoadOption).forgetDataWithoutFreeing(); //LoadOptions + LoadOption
}

CHAR16 *Old1_RemoveLoadOption(IN CONST CHAR16 *LoadOptions, IN CONST CHAR16 *LoadOption)
{
  CONST CHAR16 *Placement;
  CHAR16 *NewLoadOptions;
  UINTN   Length, Offset, OptionLength;

  //DBG("LoadOptions: '%ls', remove LoadOption: '%ls'\n", LoadOptions, LoadOption);
  // If there are no options then nothing to do
  if (LoadOptions == NULL) return NULL;
  // If there is no option to remove then duplicate original
  if (LoadOption == NULL) return EfiStrDuplicate(LoadOptions);
  // If not present duplicate original
  Placement = StrStr(LoadOptions, LoadOption);
  if (Placement == NULL) return EfiStrDuplicate(LoadOptions);

  // Get placement of option in original options
  Offset = (Placement - LoadOptions);
  Length = StrLen(LoadOptions);
  OptionLength = StrLen(LoadOption);

  // If this is just part of some larger option (contains non-space at the beginning or end)
  if ((Offset > 0 && LoadOptions[Offset - 1] != L' ') ||
      ((Offset + OptionLength) < Length && LoadOptions[Offset + OptionLength] != L' ')) {
    return EfiStrDuplicate(LoadOptions);
  }

  // Consume preceeding spaces
  while (Offset > 0 && LoadOptions[Offset - 1] == L' ') {
    OptionLength++;
    Offset--;
  }

  // Consume following spaces
  while (LoadOptions[Offset + OptionLength] == L' ') {
   OptionLength++;
  }

  // If it's the whole string return NULL
  if (OptionLength == Length) return NULL;

  if (Offset == 0) {
    // Simple case - we just need substring after OptionLength position
    NewLoadOptions = EfiStrDuplicate(LoadOptions + OptionLength);
  } else {
    // The rest of LoadOptions is Length - OptionLength, but we may need additional space and ending 0
    NewLoadOptions = (__typeof__(NewLoadOptions))AllocateZeroPool((Length - OptionLength + 2) * sizeof(CHAR16));
    // Copy preceeding substring
    CopyMem(NewLoadOptions, (void*)LoadOptions, Offset * sizeof(CHAR16));
    if ((Offset + OptionLength) < Length) {
      // Copy following substring, but include one space also
      OptionLength--;
      CopyMem(NewLoadOptions + Offset, (void*)(LoadOptions + Offset + OptionLength), (Length - OptionLength - Offset) * sizeof(CHAR16));
    }
  }
  return NewLoadOptions;
}







//
//static XString AddLoadOption(IN CONST XString& LoadOptions, IN CONST XString& LoadOption)
//{
//  // If either option strings are null nothing to do
//  if (LoadOptions.isEmpty())
//  {
//    // return LoadOption as nothing to add
//    return LoadOption;
//  }
//  // If there is no option or it is already present duplicate original
//  else {
//	  if ( LoadOptions.ExistIn(LoadOption) ) return LoadOptions;
//	  // Otherwise add option
//	  return SPrintf("%s %s", LoadOptions.c_str(), LoadOption.c_str()); //LoadOptions + LoadOption
//  }
//}
//
//static XString RemoveLoadOption(IN const XString& LoadOptions, IN const XString& LoadOption)
//{
////  CONST CHAR16 *Placement;
////  CHAR16 *NewLoadOptions;
////  UINTN   Length, Offset, OptionLength;
//
//  //DBG("LoadOptions: '%ls', remove LoadOption: '%ls'\n", LoadOptions, LoadOption);
//  // If there are no options then nothing to do
//  if (LoadOptions.isEmpty()) return ""_XS;
//  // If there is no option to remove then duplicate original
//  if (LoadOption.isEmpty()) return LoadOptions;
//  // If not present duplicate original
//  xsize Offset = LoadOptions.IdxOf(LoadOption);
//  if ( Offset == MAX_XSIZE ) return LoadOptions;
//
//  // Get placement of option in original options
////  Offset = (Placement - LoadOptions);
//  xsize Length = LoadOptions.length();
//  xsize OptionLength = LoadOption.length();
//
//  // If this is just part of some larger option (contains non-space at the beginning or end)
//  if ((Offset > 0 && LoadOptions[Offset - 1] != ' ') ||
//      ((Offset + OptionLength) < Length && LoadOptions[Offset + OptionLength] != ' ')) {
//    return LoadOptions;
//  }
//
//  // Consume preceeding spaces
//  while (Offset > 0 && LoadOptions[Offset - 1] == ' ') {
//    OptionLength++;
//    Offset--;
//  }
//
//  // Consume following spaces
//  while (LoadOptions[Offset + OptionLength] == ' ') {
//   OptionLength++;
//  }
//
//  // If it's the whole string return NULL
//  if (OptionLength == Length) return ""_XS;
//
//  XString NewLoadOptions;
//  if (Offset == 0) {
//    // Simple case - we just need substring after OptionLength position
//    NewLoadOptions = LoadOptions.SubString(OptionLength, MAX_XSIZE);
//  } else {
//    // Copy preceeding substring
//	NewLoadOptions = LoadOptions.SubString(0, Offset);
////    CopyMem(NewLoadOptions, LoadOptions, Offset * sizeof(CHAR16));
//    if ((Offset + OptionLength) < Length) {
//      // Copy following substring, but include one space also
//      OptionLength--;
//	  NewLoadOptions += LoadOptions.SubString(Offset + OptionLength, MAX_XSIZE);
////      CopyMem(NewLoadOptions + Offset, LoadOptions + Offset + OptionLength, (Length - OptionLength - Offset) * sizeof(CHAR16));
//    }
//  }
//  return NewLoadOptions;
//}
//










int BootOptions_tests()
{

#ifdef JIEF_DEBUG
//	DebugLog(2, "XStringW_tests -> Enter\n");
#endif

	{
		CHAR16* LoadOptions = NULL;
		
		LoadOptions = Old1_AddLoadOption(LoadOptions, L"opt1");
		LoadOptions = Old1_AddLoadOption(LoadOptions, L"opt2");
		LoadOptions = Old1_AddLoadOption(LoadOptions, L"opt3");
		
		if ( XString().takeValueFrom(LoadOptions) != "opt1 opt2 opt3"_XS ) return 1;
		
		CHAR16* LoadOptions1 = Old1_RemoveLoadOption(LoadOptions, L"opt1");
		if ( XString().takeValueFrom(LoadOptions1) != "opt2 opt3"_XS ) return 1;
		CHAR16* LoadOptions2 = Old1_RemoveLoadOption(LoadOptions, L"opt2");
		if ( XString().takeValueFrom(LoadOptions2) != "opt1 opt3"_XS ) return 1;
		CHAR16* LoadOptions3 = Old1_RemoveLoadOption(LoadOptions, L"opt3");
		if ( XString().takeValueFrom(LoadOptions3) != "opt1 opt2"_XS ) return 1;
	}
//	{
//		XString LoadOptions;
//		
//		LoadOptions = AddLoadOption(LoadOptions, "opt1"_XS);
//		LoadOptions = AddLoadOption(LoadOptions, "opt2"_XS);
//		LoadOptions = AddLoadOption(LoadOptions, "opt3"_XS);
//		
//		if ( LoadOptions != "opt1 opt2 opt3"_XS ) return 1;
//		
//		XString LoadOptions1 = RemoveLoadOption(LoadOptions, "opt1"_XS);
//		if ( LoadOptions1 != "opt2 opt3"_XS ) return 1;
//		XString LoadOptions2 = RemoveLoadOption(LoadOptions, "opt2"_XS);
//		if ( LoadOptions2 != "opt1 opt3"_XS ) return 1;
//		XString LoadOptions3 = RemoveLoadOption(LoadOptions, "opt3"_XS);
//		if ( LoadOptions3 != "opt1 opt2"_XS ) return 1;
//	}
	{
		XStringArray LoadOptions;
		
		LoadOptions.AddID("opt1"_XS);
		LoadOptions.AddID("opt2"_XS);
		LoadOptions.AddID("opt3"_XS);
		
		if ( LoadOptions.ConcatAll(" "_XS) != "opt1 opt2 opt3"_XS ) return 1;
		
		XStringArray LoadOptions1 = LoadOptions;
		LoadOptions1.Remove("opt1"_XS);
		if ( LoadOptions1.ConcatAll(" "_XS) != "opt2 opt3"_XS ) return 1;
		XStringArray LoadOptions2 = LoadOptions;
		LoadOptions2.Remove("opt2"_XS);
		if ( LoadOptions2.ConcatAll(" "_XS) != "opt1 opt3"_XS ) return 1;
		XStringArray LoadOptions3 = LoadOptions;
		LoadOptions3.Remove("opt3"_XS);
		if ( LoadOptions3.ConcatAll(" "_XS) != "opt1 opt2"_XS ) return 1;
	}

	return 0;
}