CoreMask.cs

/*
 * ThreadPilot - Advanced Windows Process and Power Plan Manager
 * Copyright (C) 2025 Prime Build
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, version 3 only.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 */
namespace ThreadPilot.Models
{
    using System;
    using System.Collections.Generic;
    using System.Collections.ObjectModel;
    using System.Linq;
    using CommunityToolkit.Mvvm.ComponentModel;

    /// <summary>
    /// Represents a reusable CPU core affinity mask
    /// Based on CPUSetSetter's LogicalProcessorMask.
    /// </summary>
    public partial class CoreMask : ObservableObject
    {
        [ObservableProperty]
        private string id = Guid.NewGuid().ToString();

        [ObservableProperty]
        private string name = string.Empty;

        [ObservableProperty]
        private string description = string.Empty;

        /// <summary>
        /// Gets or sets array of boolean values, one per logical core.
        /// </summary>
        public ObservableCollection<bool> BoolMask { get; set; } = new();

        public int ProfileSchemaVersion { get; set; } = CpuAffinityProfileSchemaVersions.Legacy;

        public CpuSelection? CpuSelection { get; set; }

        public CpuSelectionMigrationMetadata? CpuSelectionMigration { get; set; }

        [ObservableProperty]
        private bool isDefault = false;

        [ObservableProperty]
        private bool isEnabled = true;

        [ObservableProperty]
        private DateTime createdAt = DateTime.UtcNow;

        [ObservableProperty]
        private DateTime updatedAt = DateTime.UtcNow;

        /// <summary>
        /// Gets a value indicating whether special mask that allows all cores (no restrictions).
        /// </summary>
        public bool IsNoMask => this.BoolMask.All(b => b);

        /// <summary>
        /// Gets the count of selected cores.
        /// </summary>
        public int SelectedCoreCount => this.BoolMask.Count(b => b);

        /// <summary>
        /// Converts the boolean mask to a legacy 64-bit processor affinity value.
        /// This is only safe for single processor-group selections below CPU 64;
        /// topology-aware apply paths must prefer <see cref="CpuSelection"/>.
        /// </summary>
        public long ToProcessorAffinity()
        {
            long affinity = 0;
            for (int i = 0; i < this.BoolMask.Count; i++)
            {
                if (this.BoolMask[i])
                {
                    affinity |= 1L << i;
                }
            }
            return affinity;
        }

        /// <summary>
        /// Creates a CoreMask from a processor affinity value.
        /// </summary>
        public static CoreMask FromProcessorAffinity(long affinity, int coreCount, string name = "Custom")
        {
            var mask = new CoreMask { Name = name };
            for (int i = 0; i < coreCount; i++)
            {
                mask.BoolMask.Add(((affinity >> i) & 1) == 1);
            }
            return mask;
        }

        /// <summary>
        /// Creates a mask with all cores enabled.
        /// </summary>
        public static CoreMask CreateAllCoresMask(int coreCount)
        {
            var mask = new CoreMask
            {
                Name = "All Cores",
                Description = "Use all available CPU cores",
                IsDefault = true,
            };

            for (int i = 0; i < coreCount; i++)
            {
                mask.BoolMask.Add(true);
            }

            return mask;
        }

        /// <summary>
        /// Creates a mask with no cores (empty mask, for deletion purposes).
        /// </summary>
        public static CoreMask CreateNoMask()
        {
            return new CoreMask
            {
                Name = "No Restriction",
                Description = "Process can use all cores",
                IsDefault = false,
            };
        }

        public CoreMask Clone()
        {
            var cloned = new CoreMask
            {
                Id = Guid.NewGuid().ToString(),
                Name = this.Name + " (Copy)",
                Description = this.Description,
                IsEnabled = this.IsEnabled,
                IsDefault = false,
                ProfileSchemaVersion = this.ProfileSchemaVersion,
                CpuSelection = this.CpuSelection,
                CpuSelectionMigration = this.CpuSelectionMigration,
                CreatedAt = DateTime.UtcNow,
                UpdatedAt = DateTime.UtcNow,
            };

            foreach (var bit in this.BoolMask)
            {
                cloned.BoolMask.Add(bit);
            }

            return cloned;
        }

        public override string ToString()
        {
            return $"{this.Name} ({this.SelectedCoreCount}/{this.BoolMask.Count} cores)";
        }
    }
}