import {ECapacityAlert, EFlag, isCapacityAlert} from '../../types/api/enums';

import {
    COMPACTION_SEVERITY,
    DISK_COLOR_STATE_TO_NUMERIC_SEVERITY,
    FRONT_QUEUES_SEVERITY,
    NOT_AVAILABLE_SEVERITY,
    SPACE_SEVERITY,
    VDISK_STATE_SEVERITY_FOR_STATE_MODE,
} from './constants';
import type {DisplaySeverity, PreparedVDisk} from './types';

export type SeverityCalculator = (vDisk: PreparedVDisk) => DisplaySeverity;

/**
 * Calculate severity based only on VDiskState
 * Used in State grouping mode
 * Uses special mapping where Initial=Yellow and Error=SolidRed
 * Replicating disks (Replicated=false) remain Blue regardless of state
 */
export function calculateStateSeverity(vDisk: PreparedVDisk): DisplaySeverity {
    const vDiskState = vDisk.VDiskState;

    if (!vDiskState) {
        return NOT_AVAILABLE_SEVERITY;
    }

    const stateSeverity = VDISK_STATE_SEVERITY_FOR_STATE_MODE[vDiskState] ?? NOT_AVAILABLE_SEVERITY;

    // Replicating disks (not replicated yet) should be Blue, even if state is OK
    if (
        vDisk.Replicated === false &&
        stateSeverity === DISK_COLOR_STATE_TO_NUMERIC_SEVERITY.Green
    ) {
        return DISK_COLOR_STATE_TO_NUMERIC_SEVERITY.Blue;
    }

    return stateSeverity;
}

/**
 * Calculate severity based only on disk space usage
 * Used in Space grouping mode
 * Maps capacityAlert to detailed severity levels for visual differentiation
 */
export function calculateSpaceSeverity(vDisk: PreparedVDisk): DisplaySeverity {
    // In Space mode, CapacityAlert is the primary indicator
    // If CapacityAlert is not available, show N/D (NOT_AVAILABLE_SEVERITY)
    if (!vDisk.CapacityAlert || !isCapacityAlert(vDisk.CapacityAlert)) {
        return NOT_AVAILABLE_SEVERITY;
    }

    // Use detailed capacityAlert mapping
    const alert = vDisk.CapacityAlert;
    switch (alert) {
        case ECapacityAlert.GREEN:
            return SPACE_SEVERITY.GREEN;
        case ECapacityAlert.CYAN:
            return SPACE_SEVERITY.CYAN;
        case ECapacityAlert.LIGHTYELLOW:
            return SPACE_SEVERITY.LIGHT_YELLOW;
        case ECapacityAlert.YELLOW:
            return SPACE_SEVERITY.YELLOW;
        case ECapacityAlert.LIGHTORANGE:
            return SPACE_SEVERITY.LIGHT_ORANGE;
        case ECapacityAlert.PREORANGE:
            return SPACE_SEVERITY.PRE_ORANGE;
        case ECapacityAlert.ORANGE:
            return SPACE_SEVERITY.ORANGE;
        case ECapacityAlert.RED:
            return SPACE_SEVERITY.RED;
        case ECapacityAlert.BLACK:
            return SPACE_SEVERITY.BLACK;
        default:
            return NOT_AVAILABLE_SEVERITY;
    }
}

/**
 * Calculate severity based only on front queues
 * Used in FrontQueues grouping mode
 * Maps FrontQueues flag to detailed severity levels:
 * - Grey -> N/D (NOT_AVAILABLE_SEVERITY)
 * - Green -> OK (FRONT_QUEUES_SEVERITY.OK)
 * - Blue -> ??? (treated as Green/OK)
 * - Yellow -> Notice (FRONT_QUEUES_SEVERITY.NOTICE)
 * - Orange -> Warning (FRONT_QUEUES_SEVERITY.WARNING)
 * - Red -> Impaired (FRONT_QUEUES_SEVERITY.IMPAIRED)
 *
 * Note: Unlike Space mode, replicating disks (Replicated=false) do NOT get Blue color.
 * Instead, they show striped pattern with their actual severity color (handled in CSS).
 */
export function calculateFrontQueuesSeverity(vDisk: PreparedVDisk): DisplaySeverity {
    const frontQueues = vDisk.FrontQueues;

    if (!frontQueues) {
        return NOT_AVAILABLE_SEVERITY;
    }

    switch (frontQueues) {
        case EFlag.Grey:
            return NOT_AVAILABLE_SEVERITY;
        case EFlag.Green:
        case EFlag.Blue: // Blue is treated as OK in FrontQueues context
            return FRONT_QUEUES_SEVERITY.OK;
        case EFlag.Yellow:
            return FRONT_QUEUES_SEVERITY.NOTICE;
        case EFlag.Orange:
            return FRONT_QUEUES_SEVERITY.WARNING;
        case EFlag.Red:
            return FRONT_QUEUES_SEVERITY.IMPAIRED;
        default:
            return NOT_AVAILABLE_SEVERITY;
    }
}

/**
 * Calculate severity based on two related status flags.
 * Border color is determined by the worst flag:
 * - Both Green or Blue -> Green border (OK)
 * - Missing or Grey outranks Green -> no-data styling
 * - At least one Yellow -> Yellow border (NOTICE)
 * - At least one Orange or Red -> Red border (WARNING)
 */
export function calculateFlagPairSeverity(
    firstFlag: EFlag | undefined,
    secondFlag: EFlag | undefined,
): DisplaySeverity {
    const flags = [firstFlag, secondFlag];

    if (flags.some((flag) => flag === EFlag.Orange || flag === EFlag.Red)) {
        return COMPACTION_SEVERITY.WARNING;
    }

    if (flags.includes(EFlag.Yellow)) {
        return COMPACTION_SEVERITY.NOTICE;
    }

    return flags.every((flag) => flag === EFlag.Green || flag === EFlag.Blue)
        ? COMPACTION_SEVERITY.OK
        : NOT_AVAILABLE_SEVERITY;
}

export function calculateCompactionSeverity(vDisk: PreparedVDisk): DisplaySeverity {
    return calculateFlagPairSeverity(
        vDisk.SatisfactionRank?.FreshRank?.Flag,
        vDisk.SatisfactionRank?.LevelRank?.Flag,
    );
}

/**
 * Calculate severity for "All" grouping mode using VDiskState semantics.
 */
export function calculateAllSeverity(vDisk: PreparedVDisk): DisplaySeverity {
    return calculateStateSeverity(vDisk);
}