/** @file
  Main file for time, timezone, and date shell level 2 and shell level 3 functions.

  (C) Copyright 2012-2015 Hewlett-Packard Development Company, L.P.<BR>
  Copyright (c) 2009 - 2018, Intel Corporation. All rights reserved.<BR>
  SPDX-License-Identifier: BSD-2-Clause-Patent

**/

#include "UefiShellLevel2CommandsLib.h"

/**
  Determine if String is a valid representation for a time or date.

  @param[in] String     The pointer to the string to test.
  @param[in] Char       The delimeter character.
  @param[in] Min        The minimum value allowed.
  @param[in] Max        The maximum value allowed.
  @param[in] MinusOk    Whether negative numbers are permitted.

  @retval TRUE    String is a valid representation.
  @retval FALSE   String is invalid.
**/
BOOLEAN
InternalIsTimeLikeString (
  IN CONST CHAR16   *String,
  IN CONST CHAR16   Char,
  IN CONST UINTN    Min,
  IN CONST UINTN    Max,
  IN CONST BOOLEAN  MinusOk
  )
{
  UINTN  Count;

  Count = 0;

  if (MinusOk) {
    //
    // A single minus is ok.
    //
    if (*String == L'-') {
      String++;
    }
  }

  //
  // the first char must be numeric.
  //
  if (!ShellIsDecimalDigitCharacter (*String)) {
    return (FALSE);
  }

  //
  // loop through the characters and use the lib function
  //
  for ( ; String != NULL && *String != CHAR_NULL; String++) {
    if (*String == Char) {
      Count++;
      if (Count > Max) {
        return (FALSE);
      }

      continue;
    }

    if (!ShellIsDecimalDigitCharacter (*String)) {
      return (FALSE);
    }
  }

  if (Count < Min) {
    return (FALSE);
  }

  return (TRUE);
}

/**
  Get the current time and print a standard error message in case of failure.

  @param[in]  Command  Shell command name.
  @param[out] TheTime  Current time on success.

  @retval EFI_SUCCESS       The operation was successful.
  @retval EFI_DEVICE_ERROR  Failed to get the current time.
**/
STATIC
EFI_STATUS
GetCurrentTime (
  IN  CONST CHAR16  *Command,
  OUT EFI_TIME      *TheTime
  )
{
  EFI_STATUS  Status;

  Status = gRT->GetTime (TheTime, NULL);
  if (EFI_ERROR (Status)) {
    ShellPrintHiiDefaultEx (STRING_TOKEN (STR_GEN_UEFI_FUNC_WARN), gShellLevel2HiiHandle, Command, L"gRT->GetTime", Status);
    return EFI_DEVICE_ERROR;
  }

  return EFI_SUCCESS;
}

/**
  Print the current time in normal format.

  @param[in] TheTime  Time to print.
**/
STATIC
VOID
PrintTime (
  IN CONST EFI_TIME  *TheTime
  )
{
  UINTN  TzMinutes;

  if (TheTime->TimeZone != EFI_UNSPECIFIED_TIMEZONE) {
    TzMinutes = (ABS (TheTime->TimeZone)) % 60;

    ShellPrintHiiDefaultEx (
      STRING_TOKEN (STR_TIME_FORMAT),
      gShellLevel2HiiHandle,
      TheTime->Hour,
      TheTime->Minute,
      TheTime->Second,
      (TheTime->TimeZone > 0 ? L"-" : L"+"),
      ((ABS (TheTime->TimeZone)) / 60),
      TzMinutes
      );
  } else {
    ShellPrintHiiDefaultEx (
      STRING_TOKEN (STR_TIME_FORMAT_LOCAL),
      gShellLevel2HiiHandle,
      TheTime->Hour,
      TheTime->Minute,
      TheTime->Second
      );
  }
}

/**
  Print the daylight saving mode.

  @param[in] Daylight  Daylight mode value.
**/
STATIC
VOID
PrintDaylight (
  IN UINT8  Daylight
  )
{
  switch (Daylight) {
    case 0:
      ShellPrintHiiDefaultEx (STRING_TOKEN (STR_TIME_DST0), gShellLevel2HiiHandle);
      break;
    case EFI_TIME_ADJUST_DAYLIGHT:
      ShellPrintHiiDefaultEx (STRING_TOKEN (STR_TIME_DST1), gShellLevel2HiiHandle);
      break;
    case EFI_TIME_IN_DAYLIGHT:
      ShellPrintHiiDefaultEx (STRING_TOKEN (STR_TIME_DST2), gShellLevel2HiiHandle);
      break;
    case EFI_TIME_IN_DAYLIGHT|EFI_TIME_ADJUST_DAYLIGHT:
      ShellPrintHiiDefaultEx (STRING_TOKEN (STR_TIME_DST3), gShellLevel2HiiHandle);
      break;
    default:
      ShellPrintHiiDefaultEx (STRING_TOKEN (STR_GEN_UEFI_FUNC_ERROR), gShellLevel2HiiHandle, L"time", L"gRT->GetTime", L"TheTime.Daylight", Daylight);
      break;
  }
}

/**
  Parse the timezone command-line value.

  @param[in]  TimeZoneString  Time zone string from the command line.
  @param[out] Tz              Parsed time zone value.

  @retval SHELL_SUCCESS            The operation was successful.
  @retval SHELL_INVALID_PARAMETER  TimeZoneString is invalid.
**/
STATIC
SHELL_STATUS
GetTimeZoneFromString (
  IN  CONST CHAR16  *TimeZoneString,
  OUT INT16         *Tz
  )
{
  CONST CHAR16  *TempLocation;

  ASSERT (Tz != NULL);

  TempLocation = TimeZoneString;

  if (TempLocation == NULL) {
    *Tz = 1441;
    return SHELL_SUCCESS;
  }

  if (gUnicodeCollation->StriColl (gUnicodeCollation, (CHAR16 *)TempLocation, L"_local") == 0) {
    *Tz = EFI_UNSPECIFIED_TIMEZONE;
  } else if (TempLocation[0] == L'-') {
    *Tz = (INT16)ShellStrToUintn (++TempLocation);
    if (*Tz == -1) {
      *Tz = 1441;
    } else {
      *Tz *= (-1);
    }
  } else {
    if (TempLocation[0] == L'+') {
      *Tz = (INT16)ShellStrToUintn (++TempLocation);
    } else {
      *Tz = (INT16)ShellStrToUintn (TempLocation);
    }

    if (*Tz == -1) {
      *Tz = 1441;
    }
  }

  if (!((*Tz >= -1440) && (*Tz <= 1440)) && (*Tz != EFI_UNSPECIFIED_TIMEZONE)) {
    ShellPrintHiiDefaultEx (STRING_TOKEN (STR_GEN_PROBLEM_VAL), gShellLevel2HiiHandle, L"time", TempLocation, L"-tz");
    return SHELL_INVALID_PARAMETER;
  }

  return SHELL_SUCCESS;
}

/**
  Verify that the DateString is valid and if so set that as the current
  date.

  @param[in] DateString     The pointer to a string representation of the date.

  @retval SHELL_INVALID_PARAMETER   DateString was NULL.
  @retval SHELL_INVALID_PARAMETER   DateString was mis-formatted.
  @retval SHELL_SUCCESS             The operation was successful.
**/
SHELL_STATUS
CheckAndSetDate (
  IN CONST CHAR16  *DateString
  )
{
  EFI_TIME    TheTime;
  EFI_STATUS  Status;
  CHAR16      *DateStringCopy;
  CHAR16      *Walker;
  CHAR16      *Walker1;

  if (!InternalIsTimeLikeString (DateString, L'/', 2, 2, FALSE)) {
    return (SHELL_INVALID_PARAMETER);
  }

  Status = GetCurrentTime (L"date", &TheTime);
  if (EFI_ERROR (Status)) {
    return (SHELL_DEVICE_ERROR);
  }

  DateStringCopy = NULL;
  DateStringCopy = StrnCatGrow (&DateStringCopy, NULL, DateString, 0);
  if (DateStringCopy == NULL) {
    return (SHELL_OUT_OF_RESOURCES);
  }

  Walker = DateStringCopy;

  TheTime.Month = 0xFF;
  TheTime.Day   = 0xFF;
  TheTime.Year  = 0xFFFF;

  Walker1 = StrStr (Walker, L"/");
  if ((Walker1 != NULL) && (*Walker1 == L'/')) {
    *Walker1 = CHAR_NULL;
  }

  TheTime.Month = (UINT8)ShellStrToUintn (Walker);
  if (Walker1 != NULL) {
    Walker = Walker1 + 1;
  }

  Walker1 = Walker != NULL ? StrStr (Walker, L"/") : NULL;
  if ((Walker1 != NULL) && (*Walker1 == L'/')) {
    *Walker1 = CHAR_NULL;
  }

  if ((Walker != NULL) && (Walker[0] != CHAR_NULL)) {
    TheTime.Day = (UINT8)ShellStrToUintn (Walker);
    if (Walker1 != NULL) {
      Walker = Walker1 + 1;
    }

    Walker1 = Walker != NULL ? StrStr (Walker, L"/") : NULL;
    if ((Walker1 != NULL) && (*Walker1 == L'/')) {
      *Walker1 = CHAR_NULL;
    }

    if ((Walker != NULL) && (Walker[0] != CHAR_NULL)) {
      TheTime.Year = (UINT16)ShellStrToUintn (Walker);
    }
  }

  if (TheTime.Year < 100) {
    if (TheTime.Year >= 98) {
      TheTime.Year = (UINT16)(1900 + TheTime.Year);
    } else {
      TheTime.Year = (UINT16)(2000 + TheTime.Year);
    }
  }

  Status = gRT->SetTime (&TheTime);

  if (!EFI_ERROR (Status)) {
    return (SHELL_SUCCESS);
  }

  return (SHELL_INVALID_PARAMETER);
}

/** Main function of the 'Date' command.

  @param[in] Package    List of input parameter for the command.
**/
STATIC
SHELL_STATUS
MainCmdDate (
  LIST_ENTRY  *Package
  )
{
  EFI_STATUS    Status;
  EFI_TIME      TheTime;
  SHELL_STATUS  ShellStatus;
  CONST CHAR16  *Param1;

  ShellStatus = SHELL_SUCCESS;

  //
  // check for "-?"
  //
  if (ShellCommandLineGetFlag (Package, L"-?")) {
    ASSERT (FALSE);
    return ShellStatus;
  } else if (ShellCommandLineGetRawValue (Package, 2) != NULL) {
    ShellPrintHiiDefaultEx (STRING_TOKEN (STR_GEN_TOO_MANY), gShellLevel2HiiHandle, L"date");
    return SHELL_INVALID_PARAMETER;
  }

  //
  // If there are 0 value parameters, then print the current date
  // else If there are any value paramerers, then print error
  //
  if (ShellCommandLineGetRawValue (Package, 1) == NULL) {
    //
    // get the current date
    //
    Status = GetCurrentTime (L"date", &TheTime);
    if (EFI_ERROR (Status)) {
      return (SHELL_DEVICE_ERROR);
    }

    //
    // ShellPrintEx the date in SFO or regular format
    //
    if (ShellCommandLineGetFlag (Package, L"-sfo")) {
      //
      // Match UEFI Shell spec:
      // ShellCommand,"date"
      // Date,"DD","MM","YYYY"
      //
      ShellPrintHiiDefaultEx (STRING_TOKEN (STR_GEN_SFO_HEADER), gShellLevel2HiiHandle, L"date");
      ShellPrintHiiDefaultEx (STRING_TOKEN (STR_DATE_SFO_FORMAT), gShellLevel2HiiHandle, TheTime.Day, TheTime.Month, TheTime.Year);
    } else {
      ShellPrintHiiDefaultEx (STRING_TOKEN (STR_DATE_FORMAT), gShellLevel2HiiHandle, TheTime.Month, TheTime.Day, TheTime.Year);
    }
  } else {
    if (PcdGet8 (PcdShellSupportLevel) == 2) {
      ShellPrintHiiDefaultEx (STRING_TOKEN (STR_GEN_TOO_MANY), gShellLevel2HiiHandle, L"date");
      ShellStatus = SHELL_INVALID_PARAMETER;
    } else {
      //
      // perform level 3 operation here.
      //
      Param1 = ShellCommandLineGetRawValue (Package, 1);
      if (Param1 == NULL) {
        ShellStatus = SHELL_INVALID_PARAMETER;
      } else {
        ShellStatus = CheckAndSetDate (Param1);
      }

      if (ShellStatus != SHELL_SUCCESS) {
        ShellPrintHiiDefaultEx (STRING_TOKEN (STR_GEN_PARAM_INV), gShellLevel2HiiHandle, L"date", Param1);
        ShellStatus = SHELL_INVALID_PARAMETER;
      }
    }
  }

  return ShellStatus;
}

/**
  Function for 'date' command.

  @param[in] ImageHandle  Handle to the Image (NULL if Internal).
  @param[in] SystemTable  Pointer to the System Table (NULL if Internal).
**/
SHELL_STATUS
EFIAPI
ShellCommandRunDate (
  IN EFI_HANDLE        ImageHandle,
  IN EFI_SYSTEM_TABLE  *SystemTable
  )
{
  EFI_STATUS    Status;
  LIST_ENTRY    *Package;
  CHAR16        *ProblemParam;
  SHELL_STATUS  ShellStatus;

  ShellStatus  = SHELL_SUCCESS;
  ProblemParam = NULL;

  //
  // initialize the shell lib (we must be in non-auto-init...)
  //
  Status = ShellInitialize ();
  ASSERT_EFI_ERROR (Status);

  //
  // parse the command line
  //
  Status = ShellCommandLineParse (SfoParamList, &Package, &ProblemParam, TRUE);
  if (EFI_ERROR (Status)) {
    if ((Status == EFI_VOLUME_CORRUPTED) && (ProblemParam != NULL)) {
      ShellPrintHiiDefaultEx (STRING_TOKEN (STR_GEN_PROBLEM), gShellLevel2HiiHandle, L"date", ProblemParam);
      FreePool (ProblemParam);
      ShellStatus = SHELL_INVALID_PARAMETER;
    } else {
      ASSERT (FALSE);
    }

    return ShellStatus;
  }

  ShellStatus = MainCmdDate (Package);

  //
  // free the command line package
  //
  ShellCommandLineFreeVarList (Package);

  //
  // return the status
  //
  return (ShellStatus);
}

//
// Note "-tz" is invalid for this (non-interactive) version of 'time'.
//
STATIC CONST SHELL_PARAM_ITEM  TimeParamList2[] = {
  { L"-d", TypeValue },
  { NULL,  TypeMax   }
};

STATIC CONST SHELL_PARAM_ITEM  TimeParamList3[] = {
  { L"-d",  TypeValue },
  { L"-tz", TypeValue },
  { NULL,   TypeMax   }
};

/**
  Verify that the TimeString is valid and if so set that as the current
  time.

  @param[in] TimeString     The pointer to a string representation of the time.
  @param[in] Tz             The value to set for TimeZone.
  @param[in] Daylight       The value to set for Daylight.

  @retval SHELL_INVALID_PARAMETER   TimeString was NULL.
  @retval SHELL_INVALID_PARAMETER   TimeString was mis-formatted.
  @retval SHELL_SUCCESS             The operation was successful.
**/
SHELL_STATUS
CheckAndSetTime (
  IN CONST CHAR16  *TimeString,
  IN CONST INT16   Tz,
  IN CONST UINT8   Daylight
  )
{
  EFI_TIME    TheTime;
  EFI_STATUS  Status;
  CHAR16      *TimeStringCopy;
  CHAR16      *Walker1;
  CHAR16      *Walker2;

  if ((TimeString != NULL) && !InternalIsTimeLikeString (TimeString, L':', 1, 2, FALSE)) {
    return (SHELL_INVALID_PARAMETER);
  }

  if ((Daylight != 0xFF) && ((Daylight & (EFI_TIME_IN_DAYLIGHT|EFI_TIME_ADJUST_DAYLIGHT)) != Daylight)) {
    return (SHELL_INVALID_PARAMETER);
  }

  Status = GetCurrentTime (L"time", &TheTime);
  if (EFI_ERROR (Status)) {
    return (SHELL_DEVICE_ERROR);
  }

  if (TimeString != NULL) {
    TimeStringCopy = NULL;
    TimeStringCopy = StrnCatGrow (&TimeStringCopy, NULL, TimeString, 0);
    Walker1        = TimeStringCopy;
    TheTime.Hour   = 0xFF;
    TheTime.Minute = 0xFF;

    Walker2 = Walker1 != NULL ? StrStr (Walker1, L":") : NULL;
    if ((Walker2 != NULL) && (*Walker2 == L':')) {
      *Walker2 = CHAR_NULL;
    }

    TheTime.Hour = (UINT8)ShellStrToUintn (Walker1);
    if (Walker2 != NULL) {
      Walker1 = Walker2 + 1;
    }

    Walker2 = Walker1 != NULL ? StrStr (Walker1, L":") : NULL;
    if ((Walker2 != NULL) && (*Walker2 == L':')) {
      *Walker2       = CHAR_NULL;
      TheTime.Second = (UINT8)0;
    } else if (Walker2 == NULL) {
      TheTime.Second = (UINT8)0;
    }

    if ((Walker1 != NULL) && (Walker1[0] != CHAR_NULL)) {
      TheTime.Minute = (UINT8)ShellStrToUintn (Walker1);
      if (Walker2 != NULL) {
        Walker1 = Walker2 + 1;
        if ((Walker1 != NULL) && (Walker1[0] != CHAR_NULL)) {
          TheTime.Second = (UINT8)ShellStrToUintn (Walker1);
        }
      }
    }

    SHELL_FREE_NON_NULL (TimeStringCopy);
  }

  if ((Tz >= -1440) && (Tz <= 1440)) {
    //
    // EFI_TIME TimeZone is stored to meet the following calculation (see UEFI Spec):
    // Localtime = UTC - TimeZone
    // This means the sign must be changed for the user provided Tz.
    // EX: User wants to set TimeZone to Pacific Standard Time, so runs
    // time -tz -480 # set to UTC-08:00
    // To meet the calculation, the sign must be changed.
    //
    TheTime.TimeZone = -Tz;
  } else if (Tz == EFI_UNSPECIFIED_TIMEZONE) {
    TheTime.TimeZone = Tz;
  }

  if (Daylight != 0xFF) {
    TheTime.Daylight = Daylight;
  }

  Status = gRT->SetTime (&TheTime);

  if (!EFI_ERROR (Status)) {
    return (SHELL_SUCCESS);
  }

  return (SHELL_INVALID_PARAMETER);
}

/** Main function of the 'Time' command.

  @param[in] Package    List of input parameter for the command.
**/
STATIC
SHELL_STATUS
MainCmdTime (
  LIST_ENTRY  *Package
  )
{
  EFI_STATUS    Status;
  EFI_TIME      TheTime;
  SHELL_STATUS  ShellStatus;
  INT16         Tz;
  UINT8         Daylight;
  CONST CHAR16  *TempLocation;

  ShellStatus = SHELL_SUCCESS;

  //
  // check for "-?"
  //
  Status = GetCurrentTime (L"time", &TheTime);
  if (EFI_ERROR (Status)) {
    return (SHELL_DEVICE_ERROR);
  }

  if (ShellCommandLineGetFlag (Package, L"-?")) {
    ASSERT (FALSE);
    return ShellStatus;
  } else if (ShellCommandLineGetRawValue (Package, 2) != NULL) {
    ShellPrintHiiDefaultEx (STRING_TOKEN (STR_GEN_TOO_MANY), gShellLevel2HiiHandle, L"time");
    return SHELL_INVALID_PARAMETER;
  }

  //
  // If there are no parameters, then print the current time
  //
  if (  (ShellCommandLineGetRawValue (Package, 1) == NULL)
     && !ShellCommandLineGetFlag (Package, L"-d")
     && !ShellCommandLineGetFlag (Package, L"-tz"))
  {
    PrintTime (&TheTime);

    ShellPrintHiiDefaultEx (STRING_TOKEN (STR_GEN_CRLF), gShellLevel2HiiHandle);
  } else if (ShellCommandLineGetFlag (Package, L"-d") && (ShellCommandLineGetValue (Package, L"-d") == NULL)) {
    PrintTime (&TheTime);

    PrintDaylight (TheTime.Daylight);
  } else {
    if (PcdGet8 (PcdShellSupportLevel) == 2) {
      ShellPrintHiiDefaultEx (STRING_TOKEN (STR_GEN_TOO_MANY), gShellLevel2HiiHandle, L"time");
      ShellStatus = SHELL_INVALID_PARAMETER;
    } else {
      //
      // perform level 3 operation here.
      //
      ShellStatus = GetTimeZoneFromString (ShellCommandLineGetValue (Package, L"-tz"), &Tz);

      TempLocation = ShellCommandLineGetValue (Package, L"-d");
      if (TempLocation != NULL) {
        Daylight = (UINT8)ShellStrToUintn (TempLocation);
        //
        // The argument of "time [-d dl]" is unsigned, if the first character is '-',
        // the argument is incorrect.  That's because ShellStrToUintn() will skip past
        // any '-' sign and convert what's next, forgetting the sign is here.
        //
        if (TempLocation[0] == '-') {
          Daylight = 0xff; // make it invalid = will not use
        }

        if ((Daylight != 0) && (Daylight != 1) && (Daylight != 3)) {
          ShellPrintHiiDefaultEx (STRING_TOKEN (STR_GEN_PROBLEM_VAL), gShellLevel2HiiHandle, L"time", TempLocation, L"-d");
          ShellStatus = SHELL_INVALID_PARAMETER;
        }
      } else {
        //
        // invalid = will not use
        //
        Daylight = 0xFF;
      }

      if (ShellStatus == SHELL_SUCCESS) {
        ShellStatus = CheckAndSetTime (ShellCommandLineGetRawValue (Package, 1), Tz, Daylight);
        if (ShellStatus != SHELL_SUCCESS) {
          ShellPrintHiiDefaultEx (STRING_TOKEN (STR_GEN_PARAM_INV), gShellLevel2HiiHandle, L"time", ShellCommandLineGetRawValue (Package, 1));
          ShellStatus = SHELL_INVALID_PARAMETER;
        }
      }
    }
  }

  return ShellStatus;
}

/**
  Function for 'time' command.

  @param[in] ImageHandle  Handle to the Image (NULL if Internal).
  @param[in] SystemTable  Pointer to the System Table (NULL if Internal).
**/
SHELL_STATUS
EFIAPI
ShellCommandRunTime (
  IN EFI_HANDLE        ImageHandle,
  IN EFI_SYSTEM_TABLE  *SystemTable
  )
{
  EFI_STATUS    Status;
  LIST_ENTRY    *Package;
  CHAR16        *ProblemParam;
  SHELL_STATUS  ShellStatus;

  //
  // Initialize variables
  //
  ShellStatus  = SHELL_SUCCESS;
  ProblemParam = NULL;

  //
  // initialize the shell lib (we must be in non-auto-init...)
  //
  Status = ShellInitialize ();
  ASSERT_EFI_ERROR (Status);

  //
  // parse the command line
  //
  if (PcdGet8 (PcdShellSupportLevel) == 2) {
    Status = ShellCommandLineParseEx (TimeParamList2, &Package, &ProblemParam, TRUE, TRUE);
  } else {
    ASSERT (PcdGet8 (PcdShellSupportLevel) == 3);
    Status = ShellCommandLineParseEx (TimeParamList3, &Package, &ProblemParam, TRUE, TRUE);
  }

  if (EFI_ERROR (Status)) {
    if ((Status == EFI_VOLUME_CORRUPTED) && (ProblemParam != NULL)) {
      ShellPrintHiiDefaultEx (STRING_TOKEN (STR_GEN_PROBLEM), gShellLevel2HiiHandle, L"time", ProblemParam);
      FreePool (ProblemParam);
      ShellStatus = SHELL_INVALID_PARAMETER;
    } else {
      ASSERT (FALSE);
    }

    return ShellStatus;
  }

  ShellStatus = MainCmdTime (Package);

  //
  // free the command line package
  //
  ShellCommandLineFreeVarList (Package);

  //
  // return the status
  //
  return (ShellStatus);
}

typedef struct {
  INT16            TimeZone;
  EFI_STRING_ID    StringId;
} TIME_ZONE_ITEM;

STATIC CONST SHELL_PARAM_ITEM  TimeZoneParamList2[] = {
  { L"-l", TypeFlag },
  { L"-f", TypeFlag },
  { NULL,  TypeMax  }
};
STATIC CONST SHELL_PARAM_ITEM  TimeZoneParamList3[] = {
  { L"-l", TypeFlag      },
  { L"-f", TypeFlag      },
  { L"-s", TypeTimeValue },
  { NULL,  TypeMax       }
};

STATIC CONST TIME_ZONE_ITEM  TimeZoneList[] = {
  { 720,                      STRING_TOKEN (STR_TIMEZONE_M12)   },
  { 660,                      STRING_TOKEN (STR_TIMEZONE_M11)   },
  { 600,                      STRING_TOKEN (STR_TIMEZONE_M10)   },
  { 540,                      STRING_TOKEN (STR_TIMEZONE_M9)    },
  { 480,                      STRING_TOKEN (STR_TIMEZONE_M8)    },
  { 420,                      STRING_TOKEN (STR_TIMEZONE_M7)    },
  { 360,                      STRING_TOKEN (STR_TIMEZONE_M6)    },
  { 300,                      STRING_TOKEN (STR_TIMEZONE_M5)    },
  { 270,                      STRING_TOKEN (STR_TIMEZONE_M430)  },
  { 240,                      STRING_TOKEN (STR_TIMEZONE_M4)    },
  { 210,                      STRING_TOKEN (STR_TIMEZONE_M330)  },
  { 180,                      STRING_TOKEN (STR_TIMEZONE_M3)    },
  { 120,                      STRING_TOKEN (STR_TIMEZONE_M2)    },
  { 60,                       STRING_TOKEN (STR_TIMEZONE_M1)    },
  { 0,                        STRING_TOKEN (STR_TIMEZONE_0)     },
  { -60,                      STRING_TOKEN (STR_TIMEZONE_P1)    },
  { -120,                     STRING_TOKEN (STR_TIMEZONE_P2)    },
  { -180,                     STRING_TOKEN (STR_TIMEZONE_P3)    },
  { -210,                     STRING_TOKEN (STR_TIMEZONE_P330)  },
  { -240,                     STRING_TOKEN (STR_TIMEZONE_P4)    },
  { -270,                     STRING_TOKEN (STR_TIMEZONE_P430)  },
  { -300,                     STRING_TOKEN (STR_TIMEZONE_P5)    },
  { -330,                     STRING_TOKEN (STR_TIMEZONE_P530)  },
  { -345,                     STRING_TOKEN (STR_TIMEZONE_P545)  },
  { -360,                     STRING_TOKEN (STR_TIMEZONE_P6)    },
  { -390,                     STRING_TOKEN (STR_TIMEZONE_P630)  },
  { -420,                     STRING_TOKEN (STR_TIMEZONE_P7)    },
  { -480,                     STRING_TOKEN (STR_TIMEZONE_P8)    },
  { -540,                     STRING_TOKEN (STR_TIMEZONE_P9)    },
  { -570,                     STRING_TOKEN (STR_TIMEZONE_P930)  },
  { -600,                     STRING_TOKEN (STR_TIMEZONE_P10)   },
  { -660,                     STRING_TOKEN (STR_TIMEZONE_P11)   },
  { -720,                     STRING_TOKEN (STR_TIMEZONE_P12)   },
  { -780,                     STRING_TOKEN (STR_TIMEZONE_P13)   },
  { -840,                     STRING_TOKEN (STR_TIMEZONE_P14)   },
  { EFI_UNSPECIFIED_TIMEZONE, STRING_TOKEN (STR_TIMEZONE_LOCAL) }
};

/**
  Verify that the TimeZoneString is valid and if so set that as the current
  timezone.

  @param[in] TimeZoneString     The pointer to a string representation of the timezone.

  @retval SHELL_INVALID_PARAMETER   TimeZoneString was NULL.
  @retval SHELL_INVALID_PARAMETER   TimeZoneString was mis-formatted.
  @retval SHELL_SUCCESS             The operation was successful.
**/
SHELL_STATUS
CheckAndSetTimeZone (
  IN CONST CHAR16  *TimeZoneString
  )
{
  EFI_TIME    TheTime;
  EFI_STATUS  Status;
  CHAR16      *TimeZoneCopy;
  CHAR16      *Walker;
  CHAR16      *Walker2;
  UINTN       LoopVar;

  if (TimeZoneString == NULL) {
    return (SHELL_INVALID_PARAMETER);
  }

  if (gUnicodeCollation->StriColl (gUnicodeCollation, (CHAR16 *)TimeZoneString, L"_local") == 0) {
    Status = GetCurrentTime (L"timezone", &TheTime);
    if (EFI_ERROR (Status)) {
      return (SHELL_DEVICE_ERROR);
    }

    TheTime.TimeZone = EFI_UNSPECIFIED_TIMEZONE;
    Status           = gRT->SetTime (&TheTime);
    if (!EFI_ERROR (Status)) {
      return (SHELL_SUCCESS);
    }

    return (SHELL_INVALID_PARAMETER);
  }

  if ((TimeZoneString != NULL) && !InternalIsTimeLikeString (TimeZoneString, L':', 1, 1, TRUE)) {
    return (SHELL_INVALID_PARAMETER);
  }

  Status = GetCurrentTime (L"timezone", &TheTime);
  if (EFI_ERROR (Status)) {
    return (SHELL_DEVICE_ERROR);
  }

  TimeZoneCopy = NULL;
  TimeZoneCopy = StrnCatGrow (&TimeZoneCopy, NULL, TimeZoneString, 0);
  if (TimeZoneCopy == NULL) {
    return (SHELL_OUT_OF_RESOURCES);
  }

  Walker  = TimeZoneCopy;
  Walker2 = StrStr (Walker, L":");
  if ((Walker2 != NULL) && (*Walker2 == L':')) {
    *Walker2 = CHAR_NULL;
  }

  if (*Walker == L'-') {
    TheTime.TimeZone = (INT16)((ShellStrToUintn (++Walker)) * 60);
  } else {
    TheTime.TimeZone = (INT16)((INT16)(ShellStrToUintn (Walker)) * -60);
  }

  if (Walker2 != NULL) {
    Walker = Walker2 + 1;
  }

  if ((Walker != NULL) && (Walker[0] != CHAR_NULL)) {
    if (TheTime.TimeZone < 0) {
      TheTime.TimeZone = (INT16)(TheTime.TimeZone - (UINT8)ShellStrToUintn (Walker));
    } else {
      TheTime.TimeZone = (INT16)(TheTime.TimeZone + (UINT8)ShellStrToUintn (Walker));
    }
  }

  Status = EFI_INVALID_PARAMETER;

  for ( LoopVar = 0
        ; LoopVar < sizeof (TimeZoneList) / sizeof (TimeZoneList[0])
        ; LoopVar++
        )
  {
    if (TheTime.TimeZone == TimeZoneList[LoopVar].TimeZone) {
      Status = gRT->SetTime (&TheTime);
      break;
    }
  }

  FreePool (TimeZoneCopy);

  if (!EFI_ERROR (Status)) {
    return (SHELL_SUCCESS);
  }

  return (SHELL_INVALID_PARAMETER);
}

/** Main function of the 'TimeZone' command.

  @param[in] Package    List of input parameter for the command.
**/
STATIC
SHELL_STATUS
MainCmdTimeZone (
  LIST_ENTRY  *Package
  )
{
  EFI_STATUS    Status;
  SHELL_STATUS  ShellStatus;
  UINT8         LoopVar;
  EFI_TIME      TheTime;
  BOOLEAN       Found;
  UINTN         TzMinutes;

  ShellStatus = SHELL_SUCCESS;

  //
  // check for "-?"
  //
  if (ShellCommandLineGetCount (Package) > 1) {
    ShellPrintHiiDefaultEx (STRING_TOKEN (STR_GEN_TOO_MANY), gShellLevel2HiiHandle, L"timezone");
    return SHELL_INVALID_PARAMETER;
  } else if (ShellCommandLineGetFlag (Package, L"-?")) {
    ASSERT (FALSE);
    return ShellStatus;
  } else if (ShellCommandLineGetFlag (Package, L"-s")) {
    if ((ShellCommandLineGetFlag (Package, L"-l")) || (ShellCommandLineGetFlag (Package, L"-f"))) {
      ShellPrintHiiDefaultEx (STRING_TOKEN (STR_GEN_PARAM_INV), gShellLevel2HiiHandle, L"timezone", L"-l or -f");
      ShellStatus = SHELL_INVALID_PARAMETER;
    } else {
      ASSERT (PcdGet8 (PcdShellSupportLevel) == 3);
      if (ShellCommandLineGetValue (Package, L"-s") == NULL) {
        ShellPrintHiiDefaultEx (STRING_TOKEN (STR_GEN_NO_VALUE), gShellLevel2HiiHandle, L"timezone", L"-s");
        ShellStatus = SHELL_INVALID_PARAMETER;
      } else {
        //
        // Set the time zone
        //
        ShellStatus = CheckAndSetTimeZone (ShellCommandLineGetValue (Package, L"-s"));
        if (ShellStatus != SHELL_SUCCESS) {
          ShellPrintHiiDefaultEx (STRING_TOKEN (STR_GEN_PARAM_INV), gShellLevel2HiiHandle, L"timezone", ShellCommandLineGetValue (Package, L"-s"));
          ShellStatus = SHELL_INVALID_PARAMETER;
        }
      }
    }

    return ShellStatus;
  } else if (ShellCommandLineGetFlag (Package, L"-l")) {
    //
    // Print a list of all time zones
    //
    for ( LoopVar = 0
          ; LoopVar < sizeof (TimeZoneList) / sizeof (TimeZoneList[0])
          ; LoopVar++
          )
    {
      ShellPrintHiiDefaultEx (TimeZoneList[LoopVar].StringId, gShellLevel2HiiHandle);
    }

    return ShellStatus;
  }

  //
  // Get Current Time Zone Info
  //
  Status = GetCurrentTime (L"timezone", &TheTime);
  if (EFI_ERROR (Status)) {
    return (SHELL_DEVICE_ERROR);
  }

  if (TheTime.TimeZone != EFI_UNSPECIFIED_TIMEZONE) {
    Found = FALSE;
    for ( LoopVar = 0
          ; LoopVar < sizeof (TimeZoneList) / sizeof (TimeZoneList[0])
          ; LoopVar++
          )
    {
      if (TheTime.TimeZone == TimeZoneList[LoopVar].TimeZone) {
        if (ShellCommandLineGetFlag (Package, L"-f")) {
          //
          //  Print all info about current time zone
          //
          ShellPrintHiiDefaultEx (TimeZoneList[LoopVar].StringId, gShellLevel2HiiHandle);
        } else {
          //
          // Print basic info only
          //
          TzMinutes = (ABS (TheTime.TimeZone)) % 60;

          ShellPrintHiiDefaultEx (
            STRING_TOKEN (STR_TIMEZONE_SIMPLE),
            gShellLevel2HiiHandle,
            (TheTime.TimeZone > 0 ? L"-" : L"+"),
            (ABS (TheTime.TimeZone)) / 60,
            TzMinutes
            );
        }

        Found = TRUE;
        break;
      }
    }

    if (!Found) {
      //
      // Print basic info only
      //
      TzMinutes = (ABS (TheTime.TimeZone)) % 60;

      ShellPrintHiiDefaultEx (
        STRING_TOKEN (STR_TIMEZONE_SIMPLE),
        gShellLevel2HiiHandle,
        (TheTime.TimeZone > 0 ? L"-" : L"+"),
        (ABS (TheTime.TimeZone)) / 60,
        TzMinutes
        );

      if (ShellCommandLineGetFlag (Package, L"-f")) {
        ShellPrintHiiDefaultEx (STRING_TOKEN (STR_TIMEZONE_NI), gShellLevel2HiiHandle);
      }
    }
  } else {
    //
    // TimeZone was EFI_UNSPECIFIED_TIMEZONE (local) from GetTime()
    //
    if (ShellCommandLineGetFlag (Package, L"-f")) {
      for ( LoopVar = 0
            ; LoopVar < ARRAY_SIZE (TimeZoneList)
            ; LoopVar++
            )
      {
        if (TheTime.TimeZone == TimeZoneList[LoopVar].TimeZone) {
          //
          //  Print all info about current time zone
          //
          ShellPrintHiiDefaultEx (TimeZoneList[LoopVar].StringId, gShellLevel2HiiHandle);
          break;
        }
      }
    } else {
      //
      // Print basic info only
      //
      ShellPrintHiiDefaultEx (STRING_TOKEN (STR_TIMEZONE_SIMPLE_LOCAL), gShellLevel2HiiHandle);
    }
  }

  return ShellStatus;
}

/**
  Function for 'timezone' command.

  @param[in] ImageHandle  Handle to the Image (NULL if Internal).
  @param[in] SystemTable  Pointer to the System Table (NULL if Internal).
**/
SHELL_STATUS
EFIAPI
ShellCommandRunTimeZone (
  IN EFI_HANDLE        ImageHandle,
  IN EFI_SYSTEM_TABLE  *SystemTable
  )
{
  //
  // non interactive
  //
  EFI_STATUS    Status;
  LIST_ENTRY    *Package;
  CHAR16        *ProblemParam;
  SHELL_STATUS  ShellStatus;

  ShellStatus  = SHELL_SUCCESS;
  ProblemParam = NULL;

  //
  // initialize the shell lib (we must be in non-auto-init...)
  //
  Status = ShellInitialize ();
  ASSERT_EFI_ERROR (Status);

  //
  // parse the command line
  //
  if (PcdGet8 (PcdShellSupportLevel) == 2) {
    Status = ShellCommandLineParse (TimeZoneParamList2, &Package, &ProblemParam, TRUE);
  } else {
    ASSERT (PcdGet8 (PcdShellSupportLevel) == 3);
    Status = ShellCommandLineParseEx (TimeZoneParamList3, &Package, &ProblemParam, TRUE, TRUE);
  }

  if (EFI_ERROR (Status)) {
    if ((Status == EFI_VOLUME_CORRUPTED) && (ProblemParam != NULL)) {
      ShellPrintHiiDefaultEx (STRING_TOKEN (STR_GEN_PROBLEM), gShellLevel2HiiHandle, L"timezone", ProblemParam);
      FreePool (ProblemParam);
      ShellStatus = SHELL_INVALID_PARAMETER;
    } else {
      ASSERT (FALSE);
    }

    return ShellStatus;
  }

  ShellStatus = MainCmdTimeZone (Package);

  //
  // free the command line package
  //
  ShellCommandLineFreeVarList (Package);

  return (ShellStatus);
}