/* ========================================

  Copyright (C) 2024-2025, Amlal El Mahrouss, licensed under the Apache 2.0 license.

======================================== */

#pragma once

#include <NeKit/Config.h>
#include <NeKit/ErrorOr.h>

/// @file CoreProcessScheduler.h
/// @brief Core Process Scheduler header file.
/// @author Amlal El Mahrouss (amlal@nekernel.org)

#define kSchedMinMicroTime (AffinityKind::kStandard)
#define kSchedInvalidPID (-1)
#define kSchedProcessLimitPerTeam (32U)
#define kSchedTeamCount (256U)

#define kSchedMaxMemoryLimit (gib_cast(128)) /* max physical memory limit */
#define kSchedMaxStackSz (kib_cast(8))       /* maximum stack size */

#define kSchedNameLen (128U)

EXTERN_C void sched_idle_task(void);

namespace Kernel {
class UserProcess;
class KernelTask;
class KernelTaskScheduler;
class UserProcessScheduler;
class UserProcessTeam;

template <typename T>
struct ProcessHeapTree;

template <typename T>
struct ProcessSpecialTree;

template <typename T>
struct ProcessFileTree;

enum struct TreeKind : UInt32 {
  kInvalidTreeKind = 0U,
  kRedTreeKind     = 100U,
  kBlackTreeKind   = 101U,
  kTreeKindCount   = 3U,
};

template <typename T>
struct ProcessHeapTree {
  static constexpr auto kHeap    = true;
  static constexpr auto kFile    = false;
  static constexpr auto kSpecial = false;

  T     Entry{nullptr};
  SizeT EntrySize{0UL};
  SizeT EntryPad{0UL};

  TreeKind Color{TreeKind::kBlackTreeKind};

  struct ProcessHeapTree<T>* Parent {
    nullptr
  };
  struct ProcessHeapTree<T>* Child {
    nullptr
  };

  struct ProcessHeapTree<T>* Prev {
    nullptr
  };
  struct ProcessHeapTree<T>* Next {
    nullptr
  };
};

template <typename T>
struct ProcessFileTree {
  static constexpr auto kHeap    = false;
  static constexpr auto kFile    = true;
  static constexpr auto kSpecial = false;

  T     Entry{nullptr};
  SizeT EntrySize{0UL};
  SizeT EntryPad{0UL};

  TreeKind Color{TreeKind::kBlackTreeKind};

  struct ProcessFileTree<T>* Parent {
    nullptr
  };

  struct ProcessFileTree<T>* Child {
    nullptr
  };

  struct ProcessFileTree<T>* Prev {
    nullptr
  };

  struct ProcessFileTree<T>* Next {
    nullptr
  };
};

using ProcessCtx = UInt32;

template <typename T>
struct ProcessSpecialTree {
  static constexpr auto kHeap    = false;
  static constexpr auto kFile    = false;
  static constexpr auto kSpecial = true;

  T     Entry{nullptr};
  SizeT EntrySize{0UL};
  SizeT EntryPad{0UL};

  /// @brief a context is where the resource comes from.
  ProcessCtx EntryContext{0UL};  // could be a socket, printer, device...

  TreeKind Color{TreeKind::kBlackTreeKind};

  struct ProcessSpecialTree<T>* Parent {
    nullptr
  };

  struct ProcessSpecialTree<T>* Child {
    nullptr
  };

  struct ProcessSpecialTree<T>* Prev {
    nullptr
  };

  struct ProcessSpecialTree<T>* Next {
    nullptr
  };
};

/***********************************************************************************/
/// @brief Subsystem enum type.
/***********************************************************************************/

enum struct ProcessSubsystem : Int32 {
  kProcessSubsystemSecurity = 100,
  kProcessSubsystemUser,
  kProcessSubsystemService,
  kProcessSubsystemDriver,
  kProcessSubsystemKernel,
  kProcessSubsystemCount   = kProcessSubsystemKernel - kProcessSubsystemSecurity + 1,
  kProcessSubsystemInvalid = 0xFFFFFFF,
};

/***********************************************************************************/
//! @brief Local Process status enum.
/***********************************************************************************/
enum struct ProcessStatusKind : Int32 {
  kInvalid  = 0,
  kStarting = 100,
  kRunning,
  kKilled,
  kFrozen,
  kFinished,
  kCount = kFinished - kStarting + 1,
};

/***********************************************************************************/
//! @brief Affinity is the amount of nano-seconds this process is going to run.
/***********************************************************************************/
enum struct AffinityKind : Int32 {
  kInvalid      = 0,
  kRealTime     = 100,
  kVeryHigh     = 150,
  kHigh         = 200,
  kStandard     = 1000,
  kLowUsage     = 1500,
  kVeryLowUsage = 2000,
};

/***********************************************************************************/
//! Operators for AffinityKind
/***********************************************************************************/

inline bool operator<(AffinityKind lhs, AffinityKind rhs) {
  Int32 lhs_int = static_cast<Int32>(lhs);
  Int32 rhs_int = static_cast<Int32>(rhs);

  return lhs_int < rhs_int;
}

inline bool operator>(AffinityKind lhs, AffinityKind rhs) {
  Int32 lhs_int = static_cast<Int32>(lhs);
  Int32 rhs_int = static_cast<Int32>(rhs);

  return lhs_int > rhs_int;
}

inline bool operator<=(AffinityKind lhs, AffinityKind rhs) {
  Int32 lhs_int = static_cast<Int>(lhs);
  Int32 rhs_int = static_cast<Int32>(rhs);

  return lhs_int <= rhs_int;
}

inline bool operator>=(AffinityKind lhs, AffinityKind rhs) {
  Int32 lhs_int = static_cast<Int32>(lhs);
  Int32 rhs_int = static_cast<Int32>(rhs);

  return lhs_int >= rhs_int;
}

using PTime       = UInt64;
using ProcessTime = PTime;

/***********************************************************************************/
//! @brief Local Process Identifier type.
/***********************************************************************************/
using ProcessID = Int64;

/***********************************************************************************/
/// @note For User manager, tells where we run the code.
/***********************************************************************************/
enum struct ProcessLevelRing : Int32 {
  kRingStdUser   = 1,
  kRingSuperUser = 2,
  kRingGuestUser = 5,
  kRingCount     = 3,
};

/***********************************************************************************/
/// @brief Helper type to describe a code image.
/***********************************************************************************/
using ImagePtr = VoidPtr;

/***********************************************************************************/
/// @brief Helper class to contain a process's image and blob.
/***********************************************************************************/
struct ProcessImage final {
  explicit ProcessImage() = default;

 private:
  friend UserProcess;
  friend KernelTask;

  friend UserProcessScheduler;
  friend KernelTaskScheduler;

  ImagePtr fCode{};
  ImagePtr fBlob{};

 public:
  Bool HasCode() const { return this->fCode != nullptr; }

  Bool HasImage() const { return this->fBlob != nullptr; }

  ErrorOr<ImagePtr> LeakImage() {
    if (this->fCode) {
      return ErrorOr<ImagePtr>{this->fCode};
    }

    return ErrorOr<ImagePtr>{kErrorInvalidData};
  }

  ErrorOr<ImagePtr> LeakBlob() {
    if (this->fBlob) {
      return ErrorOr<ImagePtr>{this->fBlob};
    }

    return ErrorOr<ImagePtr>{kErrorInvalidData};
  }
};
}  // namespace Kernel