/** @file
  Linux version compare.

  Copyright (c) 2021, Mike Beaton. All rights reserved.<BR>
  SPDX-License-Identifier: BSD-3-Clause
**/

#include "LinuxBootInternal.h"

#include <Uefi.h>
#include <Library/BaseLib.h>
#include <Library/DebugLib.h>

#define IS_SECTION_BREAK(Ch)  ((Ch) == '-' || (Ch) == '~' || (Ch) == '\0')

// TODO: (?) Make this one OC library function, and
// confirm nothing similar already in OC or EDK-II.
STATIC
INTN
BoundedAsciiStrCmp (
  CONST CHAR8  *FirstString,
  CONST CHAR8  *FirstStringEnd,
  CONST CHAR8  *SecondString,
  CONST CHAR8  *SecondStringEnd
  )
{
  ASSERT (FirstString != NULL);
  ASSERT (SecondString != NULL);
  ASSERT (FirstStringEnd >= FirstString);
  ASSERT (SecondStringEnd >= SecondString);

  while ((FirstString != FirstStringEnd) &&
         (SecondString != SecondStringEnd) &&
         (*FirstString == *SecondString))
  {
    FirstString++;
    SecondString++;
  }

  if (FirstString == FirstStringEnd) {
    if (SecondString == SecondStringEnd) {
      return 0;
    } else {
      return -*SecondString;
    }
  }

  if (SecondString == SecondStringEnd) {
    return *FirstString;
  }

  return *FirstString - *SecondString;
}

STATIC
VOID
GetNextFragment (
  IN     CONST CHAR8  **Pos,
  OUT CONST CHAR8     **FragmentStart,
  OUT CONST CHAR8     **FragmentEnd,
  OUT       BOOLEAN   *IsAlphaFragment,
  OUT       BOOLEAN   *IsSectionBreak,
  OUT       CHAR8     *SectionChar
  )
{
  CHAR8  Ch;

  ASSERT (Pos             != NULL);
  ASSERT (*Pos            != NULL);
  ASSERT (FragmentStart   != NULL);
  ASSERT (FragmentEnd     != NULL);
  ASSERT (IsAlphaFragment != NULL);
  ASSERT (IsSectionBreak  != NULL);
  ASSERT (SectionChar     != NULL);

  Ch = **Pos;
  if (IS_SECTION_BREAK (Ch)) {
    *IsSectionBreak = TRUE;
    *SectionChar    = Ch;
    if (Ch != '\0') {
      ++(*Pos);
    }

    return;
  }

  *IsSectionBreak = FALSE;
  *FragmentStart  = *Pos;

  if (IS_ALPHA (Ch) || IS_DIGIT (Ch)) {
    *IsAlphaFragment = IS_ALPHA (Ch);
    do {
      ++(*Pos);
      Ch = **Pos;
    } while (*IsAlphaFragment ? IS_ALPHA (Ch) : IS_DIGIT (Ch));
  } else {
    *IsAlphaFragment = TRUE;
  }

  *FragmentEnd = *Pos;
  if (!(IS_ALPHA (Ch) || IS_DIGIT (Ch) || IS_SECTION_BREAK (Ch))) {
    ++(*Pos);
  }

  return;
}

//
// Return +1 if Version1 is higher than Version2.
// Return -1 if Version2 is higher than Version1.
// Return 0 if they sort equally.
// Non-identical strings may sort as the same (e.g. v000 and v0).
//
// Useful info on how GRUB sorts versions at https://askubuntu.com/a/1277440/693497 .
//
// This is not a replication of that logic, but does something reasonable and
// behaviourally similar (hopefully the same, for reasonable version strings).
//
//  - Versions come in sections a.b.c.d... .
//  - If matched so far, having 'more' version fragments in the same section sorts higher.
//  - - & ~ are section breaks.
//  - Any non-alpha non-digit (not just '.') is a fragment separator.
//  - Changing from alpha to digit or vice-versa is also a fragment seprator.
//  - If matched up to a section break, having a ~ section next is lower than
//    anything else (means pre-release), and having a - section next is higher
//    (just means 'more' in the version).
//
STATIC
INTN
DoVersionCompare (
  IN CONST CHAR8  *Version1,
  IN CONST CHAR8  *Version2
  )
{
  EFI_STATUS   Status;
  CONST CHAR8  *Pos1;
  CONST CHAR8  *Pos2;
  CONST CHAR8  *FragmentStart1;
  CONST CHAR8  *FragmentEnd1;
  CONST CHAR8  *FragmentStart2;
  CONST CHAR8  *FragmentEnd2;
  UINTN        VersionFragment1;
  UINTN        VersionFragment2;
  BOOLEAN      IsAlphaFragment1;
  BOOLEAN      IsAlphaFragment2;
  BOOLEAN      IsSectionBreak1;
  BOOLEAN      IsSectionBreak2;
  CHAR8        SectionChar1;
  CHAR8        SectionChar2;
  BOOLEAN      IsRescue1;
  BOOLEAN      IsRescue2;
  INTN         Compare;
  CHAR8        ChSave;

  ASSERT (Version1 != NULL);
  ASSERT (Version2 != NULL);
  if ((Version1 == NULL) || (Version2 == NULL)) {
    return 0;
  }

  //
  // Match some of what GRUB script does, c.f. askubuntu link above.
  // We can't used EndsWith as we're not as clean at getting the version
  // out without the machine-id tacked on afterwards.
  //
  IsRescue1 = AsciiStrStr (Version1, "rescue") != NULL;
  IsRescue2 = AsciiStrStr (Version2, "rescue") != NULL;

  if (IsRescue1 != IsRescue2) {
    return IsRescue2 ? +1 : -1;
  }

  Pos1 = Version1;
  Pos2 = Version2;

  while (TRUE) {
    GetNextFragment (&Pos1, &FragmentStart1, &FragmentEnd1, &IsAlphaFragment1, &IsSectionBreak1, &SectionChar1);
    GetNextFragment (&Pos2, &FragmentStart2, &FragmentEnd2, &IsAlphaFragment2, &IsSectionBreak2, &SectionChar2);

    if (IsSectionBreak1 != IsSectionBreak2) {
      return IsSectionBreak2 ? +1 : -1;
    } else if (IsSectionBreak1) {
      if (SectionChar1 != SectionChar2) {
        if ((SectionChar1 == '-') || (SectionChar2 == '~')) {
          return +1;
        }

        if ((SectionChar1 == '~') || (SectionChar2 == '-')) {
          return -1;
        }

        ASSERT (FALSE);
        return 0;
      }

      if (SectionChar1 == '\0') {
        return 0;
      }
    } else {
      if ((IsAlphaFragment1 == IsAlphaFragment2) && !IsAlphaFragment1) {
        ChSave                   = *FragmentEnd1;
        *((CHAR8 *)FragmentEnd1) = '\0';
        Status                   = AsciiStrDecimalToUintnS (FragmentStart1, NULL, &VersionFragment1);
        *((CHAR8 *)FragmentEnd1) = ChSave;
        ASSERT (!EFI_ERROR (Status));

        ChSave                   = *FragmentEnd2;
        *((CHAR8 *)FragmentEnd2) = '\0';
        Status                   = AsciiStrDecimalToUintnS (FragmentStart2, NULL, &VersionFragment2);
        *((CHAR8 *)FragmentEnd2) = ChSave;
        ASSERT (!EFI_ERROR (Status));

        Compare = VersionFragment1 - VersionFragment2;
      } else {
        Compare = BoundedAsciiStrCmp (FragmentStart1, FragmentEnd1, FragmentStart2, FragmentEnd2);
      }

      if (Compare != 0) {
        return Compare;
      }
    }
  }
}

INTN
EFIAPI
InternalVersionCompare (
  IN CONST VOID  *Version1,
  IN CONST VOID  *Version2
  )
{
  return DoVersionCompare (*((CONST CHAR8 **)Version1), *((CONST CHAR8 **)Version2));
}

INTN
EFIAPI
InternalReverseVersionCompare (
  IN CONST VOID  *Version1,
  IN CONST VOID  *Version2
  )
{
  return -DoVersionCompare (*((CONST CHAR8 **)Version1), *((CONST CHAR8 **)Version2));
}