<?php

declare(strict_types=1);

/**
 * -------------------------------------------------------------------------
 * UrBackup plugin for GLPI
 * -------------------------------------------------------------------------
 */

namespace GlpiPlugin\Urbackup;

use CommonDBTM;
use Computer;
use Glpi\Asset\AssetDefinition;
use Glpi\Asset\AssetDefinitionManager;
use DBmysql;
use Html;
use Session;

class Config extends CommonDBTM
{
    public static $rightname = 'config';

    public static function getIcon()
    {
        return 'ti ti-harddrives';
    }

    /**
     * Get type name.
     *
     * @param int $nb Number
     *
     * @return string
     */
    public static function getTypeName($nb = 0): string
    {
        return __('UrBackup configuration', 'urbackup');
    }

    /**
     * Get table name.
     *
     * @param string|null $classname Class name
     *
     * @return string
     */
    public static function getTable($classname = null): string
    {
        return 'glpi_plugin_urbackup_configs';
    }

    /**
     * Ensure default configuration.
     *
     * @return void
     */
    public static function ensureDefaultConfiguration(): void
    {
        self::ensureAssetType('Computer', true, true);
    }

    /**
     * Ensure an asset type is registered.
     *
     * @param string $itemtype  Itemtype
     * @param bool   $is_active Active
     * @param bool   $is_default Default
     *
     * @return void
     */
    public static function ensureAssetType(
        string $itemtype,
        bool $is_active = true,
        bool $is_default = false
    ): void {
        global $DB;

        $table = self::getAssetTypesTable();

        if (!$DB->tableExists($table)) {
            return;
        }

        $existing = $DB->request([
            'FROM'  => $table,
            'WHERE' => [
                'itemtype' => $itemtype,
            ],
            'LIMIT' => 1,
        ]);

        if (count($existing) > 0) {
            $row = $existing->current();

            $DB->update(
                $table,
                [
                    'is_active' => $is_active ? 1 : 0,
                    'is_default' => $is_default ? 1 : 0,
                    'date_mod' => $_SESSION['glpi_currenttime'] ?? date('Y-m-d H:i:s'),
                ],
                [
                    'id' => (int) $row['id'],
                ]
            );

            return;
        }

        $DB->insert(
            $table,
            [
                'itemtype' => $itemtype,
                'is_active' => $is_active ? 1 : 0,
                'is_default' => $is_default ? 1 : 0,
                'date_creation' => $_SESSION['glpi_currenttime'] ?? date('Y-m-d H:i:s'),
                'date_mod' => $_SESSION['glpi_currenttime'] ?? date('Y-m-d H:i:s'),
            ]
        );
    }

    /**
     * Get assettypes table name.
     *
     * @return string
     */
    public static function getAssetTypesTable(): string
    {
        return 'glpi_plugin_urbackup_assettypes';
    }

    /**
     * Check whether itemtype is enabled for UrBackup.
     *
     * @param string $itemtype Itemtype
     *
     * @return bool
     */
    public static function isItemtypeEnabled(string $itemtype): bool
    {
        global $DB;

        if ($itemtype === '') {
            return false;
        }

        if ($itemtype === 'Computer') {
            return true;
        }

        $table = self::getAssetTypesTable();

        if (!$DB->tableExists($table)) {
            return false;
        }

        $iterator = $DB->request([
            'FROM'  => $table,
            'WHERE' => [
                'itemtype'  => $itemtype,
                'is_active' => 1,
            ],
            'LIMIT' => 1,
        ]);

        return count($iterator) > 0;
    }

    /**
     * Get enabled itemtypes.
     *
     * @return array<int, string>
     */
    public static function getEnabledItemtypes(): array
    {
        global $DB;

        $types = ['Computer'];
        $table = self::getAssetTypesTable();

        if (!$DB->tableExists($table)) {
            return $types;
        }

        $iterator = $DB->request([
            'FROM'  => $table,
            'WHERE' => [
                'is_active' => 1,
            ],
            'ORDER' => 'itemtype',
        ]);

        foreach ($iterator as $row) {
            $itemtype = (string) $row['itemtype'];

            if ($itemtype !== '' && !in_array($itemtype, $types, true)) {
                $types[] = $itemtype;
            }
        }

        return $types;
    }

    /**
     * Register tabs on enabled asset types.
     *
     * @return void
     */
    public static function registerAssetTabs(): void
    {
        foreach (self::getEnabledItemtypes() as $itemtype) {
            if (!class_exists($itemtype)) {
                continue;
            }

            if (!is_a($itemtype, CommonDBTM::class, true)) {
                continue;
            }

            \Plugin::registerClass(AssetTab::class, [
                'addtabon' => $itemtype,
            ]);
        }
    }

    /**
     * Show config form.
     *
     * @param int   $ID      ID
     * @param array $options Options
     *
     * @return bool
     */
    public function showForm($ID, array $options = []): bool
    {
        Session::checkRight('config', UPDATE);

        echo "<form method='post' action='" . htmlspecialchars($options['target'] ?? '') . "'>";
        echo "<div class='center'>";
        echo "<table class='tab_cadre_fixe'>";
        echo "<tr><th colspan='4'>" . htmlspecialchars(__('UrBackup configuration', 'urbackup')) . "</th></tr>";
        echo "<tr>";
        echo "<th>" . htmlspecialchars(__('Asset type', 'urbackup')) . "</th>";
        echo "<th>" . htmlspecialchars(__('Enabled', 'urbackup')) . "</th>";
        echo "<th>" . htmlspecialchars(__('Default', 'urbackup')) . "</th>";
        echo "<th>" . htmlspecialchars(__('Type', 'urbackup')) . "</th>";
        echo "</tr>";

        foreach (self::getConfigurableAssetTypes() as $itemtype => $label) {
            $enabled = self::isItemtypeEnabled($itemtype);
            $is_default = ($itemtype === 'Computer');
            $is_asset_definition = self::isAssetDefinition($itemtype);

            echo "<tr class='tab_bg_1'>";
            echo "<td>" . htmlspecialchars($label) . "</td>";

            if ($itemtype === 'Computer') {
                echo "<td>" . htmlspecialchars(__('Always', 'urbackup')) . "</td>";
                echo "<td>" . htmlspecialchars(__('Yes', 'urbackup')) . "</td>";
            } elseif ($is_asset_definition) {
                // GLPI 11 Asset Definition
                echo "<td>";
                Html::showCheckbox([
                    'name'    => 'assettypes[' . htmlspecialchars($itemtype) . '][is_active]',
                    'checked' => $enabled,
                ]);
                echo "</td>";
                echo "<td>";
                Html::showCheckbox([
                    'name'    => 'assettypes[' . htmlspecialchars($itemtype) . '][is_default]',
                    'checked' => $is_default,
                ]);
                echo "</td>";
                echo "<td><span class='badge bg-info'>Asset Definition</span></td>";
            } else {
                // Legacy type
                echo "<td>";
                Html::showCheckbox([
                    'name'    => 'assettypes[' . htmlspecialchars($itemtype) . ']',
                    'checked' => $enabled,
                ]);
                echo "</td>";
                echo "<td>" . ($is_default ? htmlspecialchars(__('Yes', 'urbackup')) : '') . "</td>";
                echo "<td><span class='badge bg-secondary'>Legacy</span></td>";
            }

            echo "</tr>";
        }

        echo "<tr>";
        echo "<td colspan='4' class='center'>";
        echo Html::submit(__('Save', 'urbackup'), [
            'name'  => 'update',
            'class' => 'btn btn-primary',
        ]);
        echo "</td>";
        echo "</tr>";

        echo "</table>";
        echo "</div>";

        Html::closeForm();

        return true;
    }

    /**
     * Save configuration.
     *
     * @param array<string, mixed> $input Input data
     *
     * @return void
     */
    public static function saveConfiguration(array $input): void
    {
        Session::checkRight('config', UPDATE);

        $selected = $input['assettypes'] ?? [];

        foreach (self::getConfigurableAssetTypes() as $itemtype => $label) {
            if ($itemtype === 'Computer') {
                self::ensureAssetType('Computer', true, true);
                continue;
            }

            // Check if it's an Asset Definition (new format with is_active/is_default)
            if (self::isAssetDefinition($itemtype)) {
                $is_active = isset($selected[$itemtype]['is_active']) && (bool) $selected[$itemtype]['is_active'];
                $is_default = isset($selected[$itemtype]['is_default']) && (bool) $selected[$itemtype]['is_default'];
                self::ensureAssetType($itemtype, $is_active, $is_default);
            } else {
                // Legacy format (simple checkbox)
                $is_enabled = isset($selected[$itemtype]) && (bool) $selected[$itemtype];
                self::ensureAssetType($itemtype, $is_enabled, false);
            }
        }
    }

    /**
     * Get configurable asset types (legacy + GLPI 11 Asset Definition).
     *
     * @return array<string, string>
     */
    public static function getConfigurableAssetTypes(): array
    {
        $types = [
            'Computer' => Computer::getTypeName(Session::getPluralNumber()),
        ];

        // Legacy types
        $known_types = [
            'Printer',
            'Peripheral',
            'NetworkEquipment',
            'Phone',
            'Monitor',
        ];

        foreach ($known_types as $itemtype) {
            if (!class_exists($itemtype)) {
                continue;
            }

            if (!is_a($itemtype, CommonDBTM::class, true)) {
                continue;
            }

            $types[$itemtype] = $itemtype::getTypeName(Session::getPluralNumber());
        }

        // GLPI 11 Asset Definition
        if (class_exists(AssetDefinitionManager::class)) {
            try {
                $assetDefinitions = AssetDefinitionManager::getInstance()->getDefinitions(true);
                foreach ($assetDefinitions as $definition) {
                    // Access fields directly like CommonDBTM
                    $system_name = $definition->fields['system_name'] ?? '';
                    $name = $definition->fields['name'] ?? '';
                    if (!empty($system_name)) {
                        $types[$system_name] = !empty($name) ? $name : $system_name;
                    }
                }
            } catch (\Throwable $e) {
                // If AssetDefinitionManager fails, skip
            }
        }

        return $types;
    }

    /**
     * Check if itemtype is a GLPI 11 Asset Definition.
     *
     * @param string $itemtype Itemtype or system name
     *
     * @return bool
     */
    public static function isAssetDefinition(string $itemtype): bool
    {
        if (!class_exists(AssetDefinitionManager::class)) {
            return false;
        }

        try {
            $assetDefinitions = AssetDefinitionManager::getInstance()->getDefinitions(true);
            foreach ($assetDefinitions as $definition) {
                if (($definition->fields['system_name'] ?? '') === $itemtype) {
                    return true;
                }
            }
        } catch (\Throwable $e) {
            // If fails, return false
        }

        return false;
    }
}