<?php

namespace ProcessMaker\Models;

use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Support\Facades\Http;
use ProcessMaker\Exception\ExporterNotSupported;
use ProcessMaker\Exception\ValidationException;
use ProcessMaker\ImportExport\Importer;
use ProcessMaker\ImportExport\Logger;
use ProcessMaker\ImportExport\Options;
use ProcessMaker\Models\ProcessMakerModel;
use ProcessMaker\Models\Setting;
use ProcessMaker\Models\SettingsMenus;
use Spatie\MediaLibrary\HasMedia;
use Spatie\MediaLibrary\InteractsWithMedia;

class Bundle extends ProcessMakerModel implements HasMedia
{
    use HasFactory;
    use InteractsWithMedia;

    protected $guarded = ['id'];

    protected $appends = ['asset_count'];

    protected $casts = [
        'published' => 'boolean',
        'webhook_token' => 'encrypted',
    ];

    public function scopePublished($query)
    {
        return $query->where('published', true);
    }

    public function scopeEditable($query)
    {
        return $query->where('dev_link_id', null);
    }

    public function editable() : bool
    {
        return $this->dev_link_id === null;
    }

    public function assets()
    {
        return $this->hasMany(BundleAsset::class);
    }

    public function settings()
    {
        return $this->hasMany(BundleSetting::class);
    }

    public function instances()
    {
        return $this->hasMany(BundleInstance::class);
    }

    public function devLink()
    {
        return $this->belongsTo(DevLink::class, 'dev_link_id');
    }

    public function getAssetCountAttribute()
    {
        return $this->assets()->count();
    }

    public function export()
    {
        $exports = [];

        foreach ($this->assets as $bundleAsset) {
            $asset = $bundleAsset->asset;

            if (!BundleAsset::canExport($asset)) {
                throw new ExporterNotSupported();
            }

            $exports[] = $asset->export();
        }

        return $exports;
    }

    public function exportSettings()
    {
        $exports = [];

        foreach ($this->settings as $setting) {
            $exports[] = $setting;
        }

        return $exports;
    }

    public function exportSettingPayloads()
    {
        return $this->settings()->get()->map(function ($setting) {
            return $setting->export();
        });
    }

    public function syncAssets($assets)
    {
        $assetKeys = [];
        foreach ($assets as $asset) {
            $assetKeys[BundleAsset::makeKey($asset)] = true;
        }

        $existingKeys = [];
        foreach ($this->assets as $bundleAsset) {
            if (!isset($assetKeys[$bundleAsset->key])) {
                // Removing bundleAsset because it is associated but not passed to this method
                $bundleAsset->delete();
                continue;
            }

            $existingKeys[$bundleAsset->key] = true;
        }

        foreach ($assets as $asset) {
            if (isset($existingKeys[BundleAsset::makeKey($asset)])) {
                // Ignoring because it is already associated
                continue;
            }
            // Creating because it is not associated yet
            BundleAsset::create([
                'bundle_id' => $this->id,
                'asset_type' => $asset::class,
                'asset_id' => $asset->id,
            ]);
        }

        $this->refresh();
    }

    public function addAsset(ProcessMakerModel $asset)
    {
        if (!BundleAsset::canExport($asset)) {
            throw new ExporterNotSupported();
        }

        $this->validateEditable();

        $exists = $this->assets()->where('asset_type', get_class($asset))->where('asset_id', $asset->id)->exists();
        if ($exists) {
            throw ValidationException::withMessages(['*' => 'Asset already exists in bundle']);
        }

        BundleAsset::create([
            'bundle_id' => $this->id,
            'asset_type' => get_class($asset),
            'asset_id' => $asset->id,
        ]);
    }

    public function addSettings($setting, $newId, $type = null, $replaceIds = false)
    {
        $existingSetting = $this->settings()->where('setting', $setting)->first();

        if ($this->shouldSetNullConfig($newId, $type)) {
            return $this->handleNullConfig($existingSetting, $setting);
        }

        $decodedNewId = $this->parseNewId($newId);

        if ($existingSetting) {
            return $this->updateExistingSetting($existingSetting, $decodedNewId, $replaceIds);
        }

        $this->createNewSetting($setting, $decodedNewId, $type);
    }

    private function shouldSetNullConfig($newId, $type)
    {
        return is_null($newId) && is_null($type);
    }

    private function handleNullConfig($existingSetting, $setting)
    {
        if ($existingSetting) {
            $existingSetting->update(['config' => null]);
        } else {
            BundleSetting::create([
                'bundle_id' => $this->id,
                'setting' => $setting,
                'config' => null,
            ]);
        }
    }

    private function parseNewId($newId)
    {
        $decodedNewId = json_decode($newId, true);

        if (json_last_error() === JSON_ERROR_NONE) {
            if (is_array($decodedNewId)) {
                return $decodedNewId;
            } elseif (isset($decodedNewId['id'])) {
                return ['id' => [$decodedNewId['id']]];
            }

            return ['id' => [$decodedNewId]];
        }

        return ['id' => [$newId]];
    }

    private function updateExistingSetting($existingSetting, $decodedNewId, $replaceIds = false)
    {
        if (isset($decodedNewId['id']) && $decodedNewId['id'] === []) {
            $existingSetting->delete();

            return;
        }

        $config = json_decode($existingSetting->config, true) ?: ['id' => []];

        if (!isset($config['id']) || !is_array($config['id'])) {
            $config['id'] = [];
        }

        if ($replaceIds) {
            $config['id'] = $decodedNewId['id'];
        } else {
            foreach ($decodedNewId['id'] as $id) {
                $config['id'][] = $id;
            }
        }

        $config['id'] = array_values(array_unique($config['id']));
        $existingSetting->update(['config' => json_encode($config)]);
    }

    private function createNewSetting($setting, $newId, $type)
    {
        $config = ['id' => []];

        if ($type === 'settings') {
            $config = $this->getSettingsConfig($setting);
        } elseif ($type === 'ui_settings') {
            $config = $this->getUiSettingsConfig();
        } elseif ($newId && $type !== 'settings') {
            foreach ($newId['id'] as $id) {
                $config['id'][] = $id;
            }
        }

        BundleSetting::create([
            'bundle_id' => $this->id,
            'setting' => $setting,
            'config' => json_encode($config),
        ]);
    }

    private function getSettingsConfig($setting)
    {
        $config = ['id' => []];
        $settingsMenu = SettingsMenus::where('menu_group', $setting)->first();

        if ($settingsMenu) {
            $settingsKeys = Setting::where([
                ['group_id', '=', $settingsMenu->id],
                ['hidden', '=', false],
            ])->pluck('key')->toArray();

            $config['id'] = $settingsKeys;
            $config['type'] = 'settings';
        }

        return $config;
    }

    private function getUiSettingsConfig()
    {
        return [
            'id' => ['css-override', 'login-footer', 'logo-alt-text'],
            'type' => 'ui_settings',
        ];
    }

    public function addAssetToBundles(ProcessMakerModel $asset)
    {
        $message = null;
        try {
            $this->addAsset($asset);
        } catch (ValidationException $ve) {
            $message = $ve->getMessage();
        }

        return $message;
    }

    public function addSettingToBundles($setting, $newId, $type = null)
    {
        $message = null;
        try {
            $this->addSettings($setting, $newId, $type);
        } catch (ValidationException $ve) {
            $message = $ve->getMessage();
        }

        return $message;
    }

    public function validateEditable()
    {
        if (!$this->editable()) {
            throw ValidationException::withMessages(['*' => 'Bundle is not editable']);
        }
    }

    public function filesSortedByVersion()
    {
        return $this->getMedia()->map(function ($media) {
            return [
                $media,
                $media->getCustomProperty('version'),
            ];
        })->sort(function ($a, $b) {
            // newest versions first
            return version_compare($a[1], $b[1]) * -1;
        })->map(function ($item) {
            return $item[0];
        });
    }

    public function newestVersionFile()
    {
        return $this->filesSortedByVersion()->first();
    }

    public function savePayloadsToFile(array $payloads, array $payloadsSettings, $logger = null)
    {
        if ($logger === null) {
            $logger = new Logger();
        }
        $logger->status('Saving the bundle locally');

        // Filter and extract export payloads from nested array
        $exportPayloads = array_filter($payloadsSettings, function ($payload) {
            return !empty($payload[0]) && isset($payload[0]['export']);
        });

        // Extract payloads from nested array structure
        $flattenedExportPayloads = array_map(function ($payload) {
            return $payload[0];  // Tomar solo el primer elemento del array anidado
        }, array_values($exportPayloads));

        if (!empty($flattenedExportPayloads)) {
            $payloads = array_merge($payloads, $flattenedExportPayloads);
        }

        $this->addMediaFromString(
            gzencode(
                json_encode($payloads)
            ),
        )->usingFileName('payloads.json.gz')
        ->withCustomProperties(['version' => $this->version])
        ->toMediaCollection();

        // Keep only the 3 most recent versions
        $count = 0;
        foreach ($this->filesSortedByVersion() as $media) {
            if ($count >= 3) {
                $media->delete();
            }
            $count++;
        }
    }

    public function installSettings($settings)
    {
        $newSettingsKeys = collect($settings)->pluck('setting')->toArray();

        $this->settings()
            ->whereNotIn('setting', $newSettingsKeys)
            ->delete();

        foreach ($settings as $setting) {
            $this->addSettings($setting['setting'], $setting['config']);
        }
    }

    public function installSettingsPayloads(array $payloads, $mode, $logger = null)
    {
        $options = new Options([
            'mode' => $mode,
        ]);

        $assets = [];
        foreach ($payloads as $payload) {
            // Verify the type of payload without considering the order
            if (!empty($payload) && is_array($payload[0])) {
                // If it is a settings payload
                if (isset($payload[0]['setting_type'])) {
                    $this->processSettingsPayload($payload);
                }

                // If it is an export payload (it can be the same or another element)
                if (isset($payload[0]['export'])) {
                    $logger->status('Installing bundle settings on the this instance');
                    $logger->setSteps($payload);
                    $assets[] = DevLink::import($payload[0], $options, $logger);
                }
            }
        }
    }

    // Auxiliary method to process the settings
    private function processSettingsPayload($payload)
    {
        foreach ($payload as $setting) {
            switch ($setting['setting_type']) {
                case 'User Settings':
                case 'Email':
                case 'Integrations':
                case 'Log-In & Auth':
                    $settingsMenu = SettingsMenus::where('menu_group', $setting['setting_type'])->first();
                    Setting::updateOrCreate([
                        'key' => $setting['key'],
                    ], [
                        'config' => $setting['config'],
                        'name' => $setting['name'],
                        'helper' => $setting['helper'],
                        'format' => $setting['format'],
                        'hidden' => $setting['hidden'],
                        'readonly' => $setting['readonly'],
                        'ui' => $setting['ui'],
                        'group_id' => $settingsMenu->id,
                        'group' => $setting['group'],
                    ]);
                    break;
                case 'ui_settings':
                    Setting::updateOrCreate([
                        'key' => $setting['key'],
                    ], [
                        'config' => $setting['config'],
                        'name' => $setting['name'],
                        'helper' => $setting['helper'],
                        'format' => $setting['format'],
                        'hidden' => $setting['hidden'],
                        'readonly' => $setting['readonly'],
                        'ui' => $setting['ui'],
                    ]);
                    break;
            }
        }
    }

    public function install(array $payloads, $mode, $logger = null, $reinstall = false)
    {
        if ($logger === null) {
            $logger = new Logger();
        }

        $logger->status('Installing bundle on the this instance');
        $logger->setSteps($payloads);

        $options = new Options([
            'mode' => $mode,
        ]);
        $assets = [];
        foreach ($payloads as $payload) {
            $assets[] = DevLink::import($payload, $options, $logger);
        }

        if ($mode === 'update' && $reinstall === false) {
            $logger->status('Syncing bundle assets');
            $this->syncAssets($assets);
        }
    }

    public function reinstall(string $mode, Logger $logger = null)
    {
        $media = $this->newestVersionFile();

        $content = file_get_contents($media->getPath());
        $payloads = json_decode(gzdecode($content), true);
        $this->install($payloads, $mode, $logger, true);

        $logger?->setStatus('done');
    }

    public function notifyBundleUpdated()
    {
        $bundleInstances = BundleInstance::where('bundle_id', $this->id)->get();
        foreach ($bundleInstances as $bundleInstance) {
            $url = $bundleInstance->instance_url;

            try {
                $response = Http::post($url);

                if ($response->status() === 403) {
                    \Log::error("Failed to notify bundle update for URL: $url " . $response);
                }
            } catch (\Exception $e) {
                \Log::error('Error notifying bundle update: ' . $e->getMessage());
            }
        }
    }
}