TenantAtlas/app/Services/Intune/PolicyNormalizer.php

<?php

namespace App\Services\Intune;

use App\Models\Policy;
use Illuminate\Support\Arr;
use Illuminate\Support\Str;

class PolicyNormalizer
{
    /**
     * Normalize raw Intune snapshots into display-friendly blocks and warnings.
     */
    public function __construct(
        private readonly SnapshotValidator $validator,
    ) {}

    /**
     * @return array{status: string, settings: array<int, array<string, mixed>>, warnings: array<int, string>}
     */
    public function normalize(?array $snapshot, string $policyType, ?string $platform = null): array
    {
        $snapshot = $snapshot ?? [];
        $resultWarnings = [];
        $status = 'success';

        $validation = $this->validator->validate($snapshot);
        $resultWarnings = array_merge($resultWarnings, $validation['warnings']);

        $odataWarning = Policy::odataTypeWarning($snapshot, $policyType, $platform);

        if ($odataWarning) {
            $resultWarnings[] = $odataWarning;
        }

        if ($snapshot === []) {
            return [
                'status' => 'warning',
                'settings' => [],
                'warnings' => array_values(array_unique(array_merge($resultWarnings, ['No snapshot available']))),
            ];
        }

        $settings = [];

        if (isset($snapshot['omaSettings']) && is_array($snapshot['omaSettings'])) {
            $settings[] = $this->normalizeOmaSettings($snapshot['omaSettings']);
        }

        if (isset($snapshot['settings']) && is_array($snapshot['settings'])) {
            $settings[] = $this->normalizeSettingsCatalog($snapshot['settings']);
        } elseif (isset($snapshot['settingsDelta']) && is_array($snapshot['settingsDelta'])) {
            $settings[] = $this->normalizeSettingsCatalog($snapshot['settingsDelta'], 'Settings delta');
        }

        $settings[] = $this->normalizeStandard($snapshot);

        if (! empty($resultWarnings)) {
            $status = 'warning';
        }

        return [
            'status' => $status,
            'settings' => array_values(array_filter($settings)),
            'warnings' => array_values(array_unique($resultWarnings)),
        ];
    }

    /**
     * Flatten normalized settings into key/value pairs for diffing.
     *
     * @return array<string, mixed>
     */
    public function flattenForDiff(?array $snapshot, string $policyType, ?string $platform = null): array
    {
        $normalized = $this->normalize($snapshot ?? [], $policyType, $platform);
        $map = [];

        foreach ($normalized['settings'] as $block) {
            if (($block['type'] ?? null) === 'table') {
                foreach ($block['rows'] ?? [] as $row) {
                    $key = $row['path'] ?? $row['label'] ?? 'entry';
                    $map[$key] = $row['value'] ?? null;
                }

                continue;
            }

            foreach ($block['entries'] ?? [] as $entry) {
                $key = $entry['key'] ?? 'entry';
                $map[$key] = $entry['value'] ?? null;
            }
        }

        return $map;
    }

    /**
     * @param  array<int, array<string, mixed>>  $omaSettings
     */
    private function normalizeOmaSettings(array $omaSettings): array
    {
        $rows = [];

        foreach ($omaSettings as $setting) {
            if (! is_array($setting)) {
                continue;
            }

            $rows[] = [
                'path' => $setting['omaUri'] ?? $setting['path'] ?? 'n/a',
                'value' => $setting['value'] ?? $setting['displayValue'] ?? $setting['secretReferenceValueId'] ?? null,
                'label' => $setting['displayName'] ?? null,
                'description' => $setting['description'] ?? null,
            ];
        }

        return [
            'type' => 'table',
            'title' => 'OMA-URI settings',
            'rows' => $rows,
        ];
    }

    /**
     * @param  array<int, array<string, mixed>>  $settings
     */
    private function normalizeSettingsCatalog(array $settings, string $title = 'Settings'): array
    {
        $entries = [];

        foreach ($settings as $setting) {
            if (! is_array($setting)) {
                continue;
            }

            $key = $setting['displayName'] ?? $setting['name'] ?? $setting['definitionId'] ?? 'setting';
            $value = $setting['value'] ?? $setting['settingInstance']['simpleSettingValue'] ?? $setting['simpleSettingValue'] ?? null;

            if ($value === null && isset($setting['value']['value'])) {
                $value = $setting['value']['value'];
            }

            if (is_array($value)) {
                $value = json_encode($value, JSON_PRETTY_PRINT);
            }

            $entries[] = [
                'key' => $key,
                'value' => $value,
            ];
        }

        return [
            'type' => 'keyValue',
            'title' => $title,
            'entries' => $entries,
        ];
    }

    private function normalizeStandard(array $snapshot): array
    {
        $metadataKeys = [
            '@odata.context',
            '@odata.type',
            'id',
            'version',
            'createdDateTime',
            'lastModifiedDateTime',
            'supportsScopeTags',
            'roleScopeTagIds',
            'assignments',
            'createdBy',
            'lastModifiedBy',
            'omaSettings',
            'settings',
            'settingsDelta',
        ];

        $filtered = Arr::except($snapshot, $metadataKeys);
        $entries = [];

        foreach ($filtered as $key => $value) {
            if (is_array($value)) {
                $value = json_encode($value, JSON_PRETTY_PRINT);
            }

            $entries[] = [
                'key' => Str::headline((string) $key),
                'value' => $value,
            ];
        }

        return [
            'type' => 'keyValue',
            'title' => 'General',
            'entries' => $entries,
        ];
    }
}