import type {TStoragePDisk, TStorageVDisk} from '../../../types/api/storage';
import {stringifyVdiskId} from '../../../utils/dataFormatters/dataFormatters';
import {calculatePDiskSeverity} from '../../../utils/disks/calculatePDiskSeverity';
import {calculateVDiskSeverity} from '../../../utils/disks/calculateVDiskSeverity';
import {getPDiskType} from '../../../utils/disks/getPDiskType';
import {getPDiskId} from '../../../utils/disks/helpers';
import {preparePDiskSizeFields, prepareVDiskSizeFields} from '../../../utils/disks/prepareDisks';
import type {PDiskType, PreparedVDisk} from '../../../utils/disks/types';
import {parseOptionalNonNegativeNumber} from '../../../utils/utils';

export function prepareGroupsVDisk(data: TStorageVDisk = {}): PreparedVDisk {
    const hasWhiteboardData = data.HasWhiteboardData ?? Boolean(data.Whiteboard);
    const {Whiteboard: whiteboardVDisk = {}, PDisk, ...bscVDisk} = data;

    const mergedVDiskData = {
        ...whiteboardVDisk,
        ...bscVDisk,
        VDiskId: whiteboardVDisk.VDiskId,
    };

    const preparedPDisk = prepareGroupsPDisk({...PDisk, NodeId: mergedVDiskData.NodeId});

    const PDiskId = preparedPDisk?.PDiskId ?? whiteboardVDisk?.PDiskId;

    const StringifiedId = bscVDisk.VDiskId ?? stringifyVdiskId(whiteboardVDisk.VDiskId);

    const Severity = calculateVDiskSeverity(mergedVDiskData);

    const vDiskSizeFields = prepareVDiskSizeFields({
        AvailableSize: mergedVDiskData.AvailableSize,
        AllocatedSize: mergedVDiskData.AllocatedSize,
        SlotSize: PDisk?.SlotSize,
    });

    const WhiteboardSize =
        hasWhiteboardData && data.Whiteboard
            ? prepareVDiskSizeFields({
                  AvailableSize: whiteboardVDisk.AvailableSize,
                  AllocatedSize: whiteboardVDisk.AllocatedSize,
                  SlotSize: PDisk?.Whiteboard?.EnforcedDynamicSlotSize,
              }).DisplaySize
            : undefined;

    const preparedDonors = bscVDisk.Donors?.map((donor) => {
        const preparedDonor = prepareGroupsVDisk(donor);
        preparedDonor.DonorMode = true;

        // Set Recipient reference on the donor pointing back to this VDisk
        preparedDonor.Recipient = {
            NodeId: mergedVDiskData.NodeId,
            StringifiedId,
        };

        return preparedDonor;
    });

    return {
        ...mergedVDiskData,
        ...vDiskSizeFields,
        HasWhiteboardData: hasWhiteboardData,
        ...(WhiteboardSize ? {WhiteboardSize} : {}),
        PDisk: preparedPDisk,
        PDiskType: preparedPDisk.Type,
        PDiskPath: preparedPDisk.Path,
        Donors: preparedDonors,
        PDiskId,
        StringifiedId,
        Severity,
    };
}

export function prepareGroupsPDisk(data: TStoragePDisk & {NodeId?: number} = {}) {
    const hasWhiteboardData = data.HasWhiteboardData ?? Boolean(data.Whiteboard);
    const {Whiteboard: whiteboardPDisk, Status: DriveStatus, ...bscPDisk} = data;

    const mergedPDiskData = {
        ...whiteboardPDisk,
        ...bscPDisk,
        PDiskId: whiteboardPDisk?.PDiskId,
    };

    if (mergedPDiskData.PDiskId === undefined && bscPDisk.PDiskId) {
        const id = Number(bscPDisk.PDiskId.split('-')[1]);
        if (!isNaN(id)) {
            mergedPDiskData.PDiskId = id;
        }
    }

    const StringifiedId =
        bscPDisk.PDiskId ||
        getPDiskId({nodeId: mergedPDiskData.NodeId, pDiskId: mergedPDiskData.PDiskId});

    const {AllocatedPercent, AllocatedSize, AvailableSize, TotalSize} = preparePDiskSizeFields({
        AvailableSize: mergedPDiskData.AvailableSize,
        TotalSize: mergedPDiskData.TotalSize,
    });

    const whiteboardAvailableSize = parseOptionalNonNegativeNumber(whiteboardPDisk?.AvailableSize);
    const whiteboardTotalSize = parseOptionalNonNegativeNumber(whiteboardPDisk?.TotalSize);
    const whiteboardSizeFields =
        hasWhiteboardData && whiteboardPDisk
            ? preparePDiskSizeFields({
                  AvailableSize: whiteboardAvailableSize,
                  TotalSize: whiteboardTotalSize,
              })
            : undefined;
    const WhiteboardSize = whiteboardSizeFields
        ? {
              AllocatedSize:
                  whiteboardAvailableSize === undefined || whiteboardTotalSize === undefined
                      ? undefined
                      : whiteboardSizeFields.AllocatedSize,
              AllocatedPercent: whiteboardSizeFields.AllocatedPercent,
              TotalSize: whiteboardTotalSize,
          }
        : undefined;

    const Type =
        (bscPDisk.Type?.toUpperCase() as PDiskType) ?? getPDiskType(whiteboardPDisk?.Category);

    const Severity = calculatePDiskSeverity({
        State: whiteboardPDisk?.State,
        AllocatedPercent,
    });

    const SlotSize = bscPDisk.SlotSize ?? whiteboardPDisk?.EnforcedDynamicSlotSize;

    return {
        ...mergedPDiskData,
        HasWhiteboardData: hasWhiteboardData,
        StringifiedId,
        AllocatedPercent,
        AllocatedSize,
        AvailableSize,
        TotalSize,
        ...(WhiteboardSize ? {WhiteboardSize} : {}),
        Type,
        Severity,
        SlotSize,
        ExpectedSlotCount:
            mergedPDiskData.ExpectedSlotCount ?? parseOptionalNonNegativeNumber(bscPDisk.SlotCount),
        DriveStatus,
    };
}