<?php

namespace Leantime\Domain\Install\Repositories;

use Illuminate\Contracts\Container\BindingResolutionException;
use Illuminate\Database\ConnectionInterface;
use Illuminate\Database\DatabaseManager;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Cache;
use Illuminate\Support\Facades\Log;
use Illuminate\Support\Facades\Schema;
use Illuminate\Support\Str;
use Leantime\Core\Configuration\AppSettings as AppSettingCore;
use Leantime\Core\Configuration\Environment;
use Leantime\Core\Events\DispatchesEvents;
use Leantime\Core\Support\EntityRelationshipEnum;
use Leantime\Domain\Install\Services\SchemaBuilder;
use Leantime\Domain\Menu\Repositories\Menu as MenuRepository;
use Leantime\Domain\Setting\Repositories\Setting;
use Leantime\Domain\Setting\Services\SettingCache;
use PDO;
use PDOException;

class Install
{
    use DispatchesEvents;

    public string $name;

    public int $id;

    /**
     * Laravel database connection interface
     */
    private ConnectionInterface $connection;

    /**
     * Laravel database manager for creating connections
     */
    private DatabaseManager $dbManager;

    /**
     * db update scripts listed out by version number with leading zeros A.BB.CC => ABBCC
     */
    private array $dbUpdates = [
        20004,
        20100,
        20101,
        20102,
        20103,
        20104,
        20105,
        20106,
        20107,
        20108,
        20109,
        20110,
        20111,
        20112,
        20113,
        20114,
        20115,
        20116,
        20117,
        20118,
        20120,
        20121,
        20122,
        20401,
        20402,
        20405,
        20406,
        20407,
        30002,
        30003,
        30400,
        30408,
        30409,
        30410,
        30411,
        30412,
        30413,
        30500,
        30501,
        30502,
        // 30503 (zp_device_tokens) intentionally skipped — superseded by
        // 30504 which puts push columns on zp_access_tokens instead.
        30504,
        // 30505–30517 (the native-permission-engine rollout: table creation + the per-domain
        // re-seeds, added one PR at a time) were consolidated into the single 30518 migration.
        // Pre-release, so no installed DB ran the intermediate versions; fresh installs are
        // covered by SchemaBuilder + setupDB().
        30518,
        30519,
        30520,
        30521,
        30522,
        30523,
        30524,
        30525,
        30526,
        30527,
        30528,
        30529,
    ];

    /**
     * config object, passed into constructor
     */
    private Environment|string $config;

    /**
     * appSettings object, passed into constructor
     */
    private string|AppSettingCore $settings;

    /**
     * __construct - get database connection using Laravel's database manager
     */
    public function __construct(
        Environment $config,
        AppSettingCore $settings,
        DatabaseManager $dbManager
    ) {
        // Some scripts might take a long time to execute. Set timeout to 5minutes
        ini_set('max_execution_time', 300);

        $this->config = $config;
        $this->settings = $settings;
        $this->dbManager = $dbManager;

        // Use Laravel's database connection for consistency with the rest of the application
        // Detect the configured database driver (defaults to 'mysql')
        $defaultConnection = config('database.default', 'mysql');

        try {
            $this->connection = $this->dbManager->connection($defaultConnection);
        } catch (\Exception $e) {
            Log::error('Failed to establish database connection during installation: '.$e->getMessage());
            // During installation, we may need to create a temporary connection without database selection
            $this->createTemporaryConnection();
        }
    }

    /**
     * returns current database object
     */
    public function getDBObject(): ?PDO
    {
        return $this->connection->getPdo();
    }

    /**
     * Create a temporary database connection for installation purposes
     * This is used when the main database connection fails during installation
     * Supports both MySQL and PostgreSQL
     */
    private function createTemporaryConnection(): void
    {
        try {
            $driver = config('database.default', 'mysql');

            if ($driver === 'pgsql') {
                // PostgreSQL temporary connection
                $config = [
                    'driver' => 'pgsql',
                    'host' => $this->config->dbHost,
                    'port' => $this->config->dbPort ?? 5432,
                    'database' => 'postgres', // Connect to default postgres database
                    'username' => $this->config->dbUser,
                    'password' => $this->config->dbPassword,
                    'charset' => 'utf8',
                    'prefix' => '',
                    'search_path' => 'public',
                    'sslmode' => env('LEAN_DB_SSLMODE', 'prefer'),
                    'options' => [
                        PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
                    ],
                ];
            } else {
                // MySQL temporary connection (default)
                $config = [
                    'driver' => 'mysql',
                    'host' => $this->config->dbHost,
                    'port' => $this->config->dbPort ?? 3306,
                    'username' => $this->config->dbUser,
                    'password' => $this->config->dbPassword,
                    'charset' => 'utf8mb4',
                    'collation' => 'utf8mb4_unicode_ci',
                    'options' => [
                        PDO::MYSQL_ATTR_INIT_COMMAND => 'SET NAMES utf8mb4,sql_mode="NO_ENGINE_SUBSTITUTION"',
                        PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
                    ],
                ];
            }

            // Use Laravel's DB manager to create a temporary connection
            config(['database.connections.install_temp' => $config]);
            $this->connection = $this->dbManager->connection('install_temp');
        } catch (\Exception $e) {
            Log::error('Failed to create temporary database connection: '.$e->getMessage());
            throw $e;
        }
    }

    /**
     * checkIfInstalled checks if zp user table exists (and assumes that leantime is installed)
     */
    public function checkIfInstalled(): bool
    {

        if (Cache::has('isInstalled') && Cache::get('isInstalled') === true) {
            return true;
        }

        try {

            // Select the database - MySQL uses USE, PostgreSQL uses search_path
            $this->selectDatabase($this->config->dbDatabase);

            $count = $this->connection->table('zp_user')->count();

            Cache::set('isInstalled', true);

            return true;
        } catch (PDOException $e) {

            Cache::forget('isInstalled');

            Log::error($e);

            return false;
        }
    }

    /**
     * Select/switch to a specific database
     * Handles database-specific syntax for MySQL vs PostgreSQL
     */
    private function selectDatabase(string $database): void
    {
        $driver = $this->connection->getDriverName();

        if ($driver === 'pgsql') {
            // PostgreSQL: reconnect with the correct database
            // Since we can't "USE" a database in PostgreSQL like MySQL,
            // the database is specified at connection time
            $this->connection->getPdo()->exec('SET search_path TO public');
        } else {
            // MySQL: USE statement
            $this->connection->statement('USE `'.$database.'`');
        }
    }

    /**
     * setupDB installs database using database-agnostic Schema Builder
     *
     * @param  array  $values  Form values for admin user and company information
     * @param  string  $db
     */
    public function setupDB(array $values, $db = ''): bool
    {
        try {
            // Select the database
            $dbName = $db ?: $this->config->dbDatabase;
            $this->selectDatabase($dbName);

            $pwReset = Str::random(32);
            session()->put('pwReset', $pwReset);

            // Use SchemaBuilder for database-agnostic table creation
            $schemaBuilder = app()->make(SchemaBuilder::class);
            $schemaBuilder->createAllTables();
            $schemaBuilder->insertInitialData($values, $pwReset);

            // Seed the permission engine for fresh installs: sync the domain-declared
            // vocabulary into zp_permissions and grant the built-in roles their defaults.
            // (update_sql_* seeds existing installs; this covers the fresh-install path.)
            $permissionSeeder = app()->make(\Leantime\Core\Auth\Permissions\PermissionSeeder::class);
            $permissionSeeder->syncDiscoveredPermissions();
            $permissionSeeder->seedBuiltInRoles();

            return true;
        } catch (\Exception $e) {
            Log::error($e);

            return false;
        }
    }

    /**
     * updateDB main entry point to update the db based on version number. Executes all missing db update scripts
     *
     * @throws BindingResolutionException
     */
    public function updateDB(): array|bool
    {

        // Forget all the versions we think we know and start fresh
        session()->forget('db-version');
        $settingsCacheService = app()->make(SettingCache::class);
        $settingsCacheService->forget('db-version');

        $errors = [];

        $this->selectDatabase($this->config->dbDatabase);

        $versionArray = explode('.', $this->settings->dbVersion);
        if (is_array($versionArray) && count($versionArray) == 3) {
            $major = $versionArray[0];
            $minor = str_pad($versionArray[1], 2, '0', STR_PAD_LEFT);
            $patch = str_pad($versionArray[2], 2, '0', STR_PAD_LEFT);
            $newDBVersion = $major.$minor.$patch;
        } else {
            $errors[0] = 'Problem identifying the version number';

            return $errors;
        }

        $setting = app()->make(Setting::class);
        $dbVersion = $setting->getSetting('db-version');
        $currentDBVersion = 0;
        if ($dbVersion) {
            $versionArray = explode('.', $dbVersion);
            if (is_array($versionArray) && count($versionArray) == 3) {
                $major = $versionArray[0];
                $minor = str_pad($versionArray[1], 2, '0', STR_PAD_LEFT);
                $patch = str_pad($versionArray[2], 2, '0', STR_PAD_LEFT);
                $currentDBVersion = $major.$minor.$patch;
            } else {
                $errors[0] = 'Problem identifying the version number';

                return $errors;
            }
        }

        if ($currentDBVersion == $newDBVersion) {

            session()->forget('isUpdated');
            session()->forget('dbVersion');

            return true;
        }

        // The version changed: cached routes, plugin lists etc. may reference classes or
        // methods that no longer exist in the new codebase. Everything in the installation
        // store is re-derivable, so drop it wholesale before running the updates.
        Cache::store('installation')->clear();

        // Find all update functions that need to be executed
        foreach ($this->dbUpdates as $updateVersion) {
            if ($currentDBVersion < $updateVersion) {
                $functionName = 'update_sql_'.$updateVersion;

                $result = $this->$functionName();

                if ($result !== true) {
                    $errors = array_merge($errors, $result);
                } else {
                    // Update version number in db
                    try {

                        $settingsService = app()->make(\Leantime\Domain\Setting\Services\Setting::class);
                        $settingsService->saveSetting('db-version', $this->convert_version($updateVersion));

                        // $stmn = $this->database->prepare("INSERT INTO zp_settings (`key`, `value`) VALUES ('db-version', '".$this->settings->dbVersion."') ON DUPLICATE KEY UPDATE `value` = '".$this->settings->dbVersion."'");
                        // $stmn->execute();

                        $currentDBVersion = $updateVersion;
                    } catch (PDOException $e) {
                        Log::error($e);
                        Log::error($e->getTraceAsString());

                        return ['There was a problem updating the database'];
                    }
                }

                if (count($errors) > 0) {
                    return $errors;
                }
            }
        }

        session()->forget('isUpdated');
        session()->forget('dbVersion');

        return true;
    }

    private function convert_version($inputVersion): string
    {
        // $inputVersion is in the format of 10000 and needs to be converted to 1.0.0
        $versionString = str_pad((string) $inputVersion, 5, '0', STR_PAD_LEFT);

        $major = intval(substr($versionString, 0, -4));
        $minor = intval(substr($versionString, -4, 2));
        $patch = intval(substr($versionString, -2));

        return $major.'.'.$minor.'.'.$patch;
    }

    /**
     * sqlPrep - returns all the create table statements
     */
    private function sqlPrep(): string
    {

        $sql = "
                CREATE TABLE `zp_calendar` (
                    `id` int(11) NOT NULL AUTO_INCREMENT,
                    `userId` int(11) DEFAULT NULL,
                    `dateFrom` datetime DEFAULT NULL,
                    `dateTo` datetime DEFAULT NULL,
                    `description` text,
                    `kind` varchar(255) DEFAULT NULL,
                    `allDay` varchar(10) DEFAULT NULL,
                    PRIMARY KEY (`id`),
                    KEY `idx_calendar_userId_dateFrom_dateTo` (`userId`, `dateFrom`, `dateTo`)
                ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;

                CREATE TABLE `zp_canvas` (
                    `id` int(11) NOT NULL AUTO_INCREMENT,
                    `title` varchar(255) DEFAULT NULL,
                    `author` int(10) DEFAULT NULL,
                    `created` datetime DEFAULT NULL,
                    `projectId` INT NULL,
                    `type` VARCHAR(45) NULL,
                    `description` TEXT,
                    `color` VARCHAR(50) DEFAULT 'ocean',
                    `modified` datetime DEFAULT NULL,
                    PRIMARY KEY (`id`),
                    KEY `ProjectIdType` (`projectId` ASC, `type` ASC),
                    KEY `idx_canvas_type_id` (`type`, `id`)
                ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;

                CREATE TABLE `zp_canvas_items` (
                    `id` int(11) NOT NULL AUTO_INCREMENT,
                    `description` MEDIUMTEXT,
                    `assumptions` text,
                    `data` MEDIUMTEXT,
                    `conclusion` text,
                    `why_this_matters` text,
                    `starting_picture` text,
                    `box` varchar(255) DEFAULT NULL,
                    `author` int(11) DEFAULT NULL,
                    `created` datetime DEFAULT NULL,
                    `modified` datetime DEFAULT NULL,
                    `canvasId` int(11) DEFAULT NULL,
                    `sortindex` int(11) DEFAULT NULL,
                    `status` varchar(255) DEFAULT NULL,
                    `relates` varchar(255) DEFAULT NULL,
                    `milestoneId` VARCHAR(255) NULL,
                    `title` varchar(255) NULL,
                    `parent` int NULL,
                    `featured` int NULL,
                    `tags` text NULL,
                    `kpi` INT NULL DEFAULT NULL,
                    `data1` MEDIUMTEXT NULL DEFAULT NULL,
                    `data2` MEDIUMTEXT NULL DEFAULT NULL,
                    `data3` MEDIUMTEXT NULL DEFAULT NULL,
                    `data4` MEDIUMTEXT NULL DEFAULT NULL,
                    `data5` MEDIUMTEXT NULL DEFAULT NULL,
                    `startDate` DATETIME NULL DEFAULT NULL,
                    `endDate` DATETIME NULL DEFAULT NULL,
                    `setting` TEXT NULL DEFAULT NULL,
                    `metricType` VARCHAR(45) DEFAULT NULL,
                    `startValue` double(10,2) NULL DEFAULT NULL,
                    `currentValue` double(10,2) NULL DEFAULT NULL,
                    `endValue` double(10,2) NULL DEFAULT NULL,
                    `impact` INT NULL DEFAULT NULL,
                    `effort` INT NULL DEFAULT NULL,
                    `probability` INT NULL DEFAULT NULL,
                    `action` TEXT NULL DEFAULT NULL,
                    `assignedTo` INT NULL DEFAULT NULL,
                    PRIMARY KEY (`id`),
                    KEY `CanvasLookUp` (`canvasId` ASC, `box` ASC),
                    KEY `idx_canvas_items_box_milestoneId` (`box`, `milestoneId`),
                    KEY `idx_canvas_items_box_status_author` (`box`, `status`, `author`),
                    KEY `idx_canvas_items_parent_title` (`parent`, `title`)
                ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;

                CREATE TABLE `zp_approvals` (
                    `id` int auto_increment,
                    `module` varchar(100) NULL,
                    `entityId` int NULL,
                    `requestorId` int NULL,
                    `approverId` int NULL,
                    `approvalStatus` int NULL,
                    `requestedOn` datetime NULL,
                    `lastStatusChange` datetime NULL,
                    PRIMARY KEY (`id`)
                ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;

                CREATE TABLE `zp_clients` (
                    `id` int(11) NOT NULL AUTO_INCREMENT,
                    `name` varchar(200) DEFAULT NULL,
                    `street` varchar(200) DEFAULT NULL,
                    `zip` int(10) DEFAULT NULL,
                    `city` varchar(50) DEFAULT NULL,
                    `state` varchar(50) DEFAULT NULL,
                    `country` varchar(50) DEFAULT NULL,
                    `phone` varchar(50) DEFAULT NULL,
                    `internet` varchar(200) DEFAULT NULL,
                    `published` int(1) DEFAULT NULL,
                    `age` int(3) DEFAULT NULL,
                    `email` varchar(255) DEFAULT NULL,
                    `modified` datetime DEFAULT NULL,
                    PRIMARY KEY (`id`)
                ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;

                INSERT INTO `zp_clients`(`id`,`name`,`street`,`zip`,`city`,`state`,`country`,`phone`,`internet`,`published`,`age`,`email`) VALUES (1,:company,'',0,'','','','','',NULL,NULL,'');

                CREATE TABLE `zp_comment` (
                    `id` int(11) unsigned NOT NULL AUTO_INCREMENT,
                    `module` varchar(200) DEFAULT NULL,
                    `userId` int(11) DEFAULT NULL,
                    `commentParent` int(11) DEFAULT NULL,
                    `date` datetime DEFAULT NULL,
                    `moduleId` int(11) DEFAULT NULL,
                    `text` text,
                    `status` varchar(50) null,
                    PRIMARY KEY (`id`),
                    KEY `idx_comment_moduleId_module_commentParent` (`moduleId`, `module`, `commentParent`),
                    KEY `idx_comment_userId_module` (`userId`, `module`)
                ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;

                CREATE TABLE `zp_file` (
                    `id` int(11) unsigned NOT NULL AUTO_INCREMENT,
                    `module` enum('project','ticket','client','user','lead','export','private') DEFAULT NULL,
                    `moduleId` int(11) DEFAULT NULL,
                    `userId` int(11) DEFAULT NULL,
                    `extension` varchar(10) DEFAULT NULL,
                    `encName` varchar(255) DEFAULT NULL,
                    `realName` varchar(255) DEFAULT NULL,
                    `date` datetime DEFAULT NULL,
                    PRIMARY KEY (`id`),
                    KEY `idx_file_module_moduleId_userId` (`module`, `moduleId`, `userId`)
                ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;

                CREATE TABLE `zp_gcallinks` (
                    `id` int(11) NOT NULL AUTO_INCREMENT,
                    `userId` int(255) DEFAULT NULL,
                    `url` text,
                    `name` varchar(255) DEFAULT NULL,
                    `colorClass` varchar(100) DEFAULT NULL,
                    PRIMARY KEY (`id`),
                    KEY `idx_gcallinks_userId` (`userId`)
                ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;

                CREATE TABLE `zp_note` (
                    `id` int(11) unsigned NOT NULL AUTO_INCREMENT,
                    `userId` int(11) DEFAULT NULL,
                    `title` varchar(255) DEFAULT NULL,
                    `description` text,
                    PRIMARY KEY (`id`)
                ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;

                CREATE TABLE `zp_projects` (
                    `id` int(11) NOT NULL AUTO_INCREMENT,
                    `name` varchar(100) DEFAULT NULL,
                    `clientId` int(100) DEFAULT NULL,
                    `details` text,
                    `state` int(2) DEFAULT NULL,
                    `hourBudget` varchar(255) NOT NULL,
                    `dollarBudget` int(11) DEFAULT NULL,
                    `active` int(11) DEFAULT NULL,
                    `menuType` MEDIUMTEXT DEFAULT NULL,
                    `psettings` MEDIUMTEXT NULL,
                    `parent` INT(11) NULL,
                    `type` VARCHAR(45) NULL,
                    `start` DATETIME NULL,
                    `end` DATETIME NULL,
                    `created` DATETIME NULL,
                    `modified` DATETIME NULL,
                    `avatar` MEDIUMTEXT NULL ,
                    `cover` MEDIUMTEXT NULL,
                    `sortIndex` INT(11) NULL,
                    PRIMARY KEY (`id`)
                ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;

                CREATE TABLE `zp_punch_clock` (
                    `id` int(11) unsigned NOT NULL AUTO_INCREMENT,
                    `userId` int(11) NOT NULL,
                    `minutes` int(11) DEFAULT NULL,
                    `hours` int(11) DEFAULT NULL,
                    `punchIn` int(11) DEFAULT NULL,
                    PRIMARY KEY (`id`,`userId`)
                ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;

                CREATE TABLE `zp_read` (
                    `id` int(11) unsigned NOT NULL AUTO_INCREMENT,
                    `module` enum('ticket','message') DEFAULT NULL,
                    `moduleId` int(11) DEFAULT NULL,
                    `userId` int(11) DEFAULT NULL,
                    PRIMARY KEY (`id`)
                ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;

                CREATE TABLE `zp_relationuserproject` (
                    `id` int(11) NOT NULL AUTO_INCREMENT,
                    `userId` int(11) DEFAULT NULL,
                    `projectId` int(11) DEFAULT NULL,
                    `wage` int(11) DEFAULT NULL,
                    `projectRole` varchar(20),
                    PRIMARY KEY (`id`),
                    KEY zp_relationuserproject_projectId_index (`projectId`),
                    KEY zp_relationuserproject_userId_index  (`userId`)
                ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;

                CREATE TABLE `zp_tickethistory` (
                    `id` int(11) unsigned NOT NULL AUTO_INCREMENT,
                    `userId` int(11) DEFAULT NULL,
                    `ticketId` int(11) DEFAULT NULL,
                    `changeType` varchar(255) DEFAULT NULL,
                    `changeValue` varchar(150) DEFAULT NULL,
                    `dateModified` datetime DEFAULT NULL,
                    PRIMARY KEY (`id`)
                ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;

                CREATE TABLE `zp_goal_history` (
                    `id` int(11) unsigned NOT NULL AUTO_INCREMENT,
                    `itemId` int(11) NOT NULL,
                    `value` double DEFAULT NULL,
                    `userId` int(11) DEFAULT NULL,
                    `dateRecorded` datetime DEFAULT NULL,
                    PRIMARY KEY (`id`),
                    KEY `idx_goal_history_item_date` (`itemId`,`dateRecorded`)
                ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;

                CREATE TABLE `zp_tickets` (
                    `id` int(11) NOT NULL AUTO_INCREMENT,
                    `projectId` int(11) DEFAULT NULL,
                    `headline` varchar(255) DEFAULT NULL,
                    `description` text,
                    `acceptanceCriteria` text,
                    `outcomeImpact` text,
                    `date` datetime DEFAULT NULL,
                    `dateToFinish` datetime DEFAULT NULL,
                    `priority` varchar(60) DEFAULT NULL,
                    `status` int(2) DEFAULT NULL,
                    `userId` int(11) DEFAULT NULL,
                    `os` varchar(30) DEFAULT NULL,
                    `browser` varchar(30) DEFAULT NULL,
                    `resolution` varchar(30) DEFAULT NULL,
                    `component` varchar(100) DEFAULT NULL,
                    `version` varchar(20) DEFAULT NULL,
                    `url` varchar(100) DEFAULT NULL,
                    `dependingTicketId` int(100) DEFAULT NULL,
                    `editFrom` datetime DEFAULT NULL,
                    `editTo` datetime DEFAULT NULL,
                    `editorId` varchar(75) DEFAULT NULL,
                    `planHours` float DEFAULT NULL,
                    `hourRemaining` float DEFAULT NULL,
                    `type` varchar(255) DEFAULT NULL,
                    `production` int(1) DEFAULT '0',
                    `staging` int(1) DEFAULT '0',
                    `storypoints` float DEFAULT NULL,
                    `sprint` int(100) DEFAULT NULL,
                    `sortindex` bigint(20) DEFAULT NULL,
                    `kanbanSortIndex` bigint(20) DEFAULT NULL,
                    `tags` varchar(255) DEFAULT NULL,
                    `milestoneid` INT NULL,
                    `leancanvasitemid` INT NULL,
                    `retrospectiveid` INT NULL,
                    `ideaid` INT NULL,
                    `zp_ticketscol` VARCHAR(45) NULL,
                    `modified` datetime DEFAULT NULL,
                    PRIMARY KEY (`id`),
                    KEY `ProjectUserId` (`projectId`,`userId`),
                    KEY `StatusSprint` (`status`,`sprint`),
                    KEY `Sorting` (`sortindex`),
                    KEY `idx_tickets_editorId` (`editorId`),
                    KEY `idx_tickets_milestoneid` (`milestoneid`),
                    KEY `idx_tickets_editFrom` (`editFrom`),
                    KEY `idx_tickets_editTo` (`editTo`),
                    KEY `idx_tickets_dateToFinish` (`dateToFinish`),
                    KEY `idx_tickets_modified` (`modified`),
                    KEY `idx_tickets_projectId_status` (`projectId`, `status`),
                    KEY `idx_tickets_projectId_type` (`projectId`, `type`),
                    KEY `idx_tickets_status_type` (`status`, `type`)
                ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;

                CREATE TABLE `zp_timesheets` (
                    `id` int(255) NOT NULL AUTO_INCREMENT,
                    `userId` int(11) DEFAULT NULL,
                    `ticketId` int(11) DEFAULT NULL,
                    `workDate` datetime DEFAULT NULL,
                    `hours` float DEFAULT NULL,
                    `description` text,
                    `kind` varchar(175) DEFAULT NULL,
                    `invoicedEmpl` int(2) DEFAULT NULL,
                    `invoicedComp` int(2) DEFAULT NULL,
                    `invoicedEmplDate` datetime DEFAULT NULL,
                    `invoicedCompDate` datetime DEFAULT NULL,
                    `rate` varchar(255) DEFAULT NULL,
                    `paid` int(2) DEFAULT NULL,
                    `paidDate` datetime DEFAULT NULL,
                    `modified` datetime DEFAULT NULL,
                    PRIMARY KEY (`id`),
                    UNIQUE KEY `Unique` (`userId`,`ticketId`,`workDate`,`kind`),
                    KEY `idx_timesheets_ticketId` (`ticketId`),
                    KEY `idx_timesheets_userId_workDate` (`userId`, `workDate`),
                    KEY `idx_timesheets_ticketId_workDate` (`ticketId`, `workDate`)
                ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;

                CREATE TABLE `zp_user` (
                    `id` int(11) NOT NULL AUTO_INCREMENT,
                    `username` varchar(175) NOT NULL,
                    `password` varchar(255) NOT NULL DEFAULT '',
                    `firstname` varchar(100) NOT NULL,
                    `lastname` varchar(100) NOT NULL,
                    `phone` varchar(25) NOT NULL,
                    `profileId` varchar(100) NOT NULL DEFAULT '',
                    `lastlogin` datetime DEFAULT NULL,
                    `status` varchar(1) NOT NULL DEFAULT 'A',
                    `expires` DATETIME DEFAULT NULL,
                    `role` varchar(200) NOT NULL,
                    `session` varchar(100) DEFAULT NULL,
                    `sessiontime` varchar(50) DEFAULT NULL,
                    `wage` int(11) DEFAULT NULL,
                    `hours` int(11) DEFAULT NULL,
                    `weekly_hours` int(11) DEFAULT NULL,
                    `employment_type` varchar(20) DEFAULT NULL,
                    `description` text,
                    `clientId` int(11) DEFAULT NULL,
                    `notifications` int(2) DEFAULT NULL,
                    `pwReset` varchar(100) DEFAULT NULL,
                    `pwResetExpiration` datetime DEFAULT NULL,
                    `pwResetCount` INT(5) DEFAULT NULL,
                    `forcePwReset` TINYINT DEFAULT NULL,
                    `lastpwd_change` DATETIME DEFAULT NULL,
                    `settings` TEXT NULL,
                    `twoFAEnabled` tinyint(1) DEFAULT '0',
                    `twoFASecret` varchar(200) DEFAULT NULL,
                    `createdOn` DATETIME DEFAULT NULL,
                    `source` varchar(200) DEFAULT NULL,
                    `jobTitle` VARCHAR(200) NULL,
                    `jobLevel` VARCHAR(50) NULL,
                    `department` VARCHAR(200) NULL,
                    `modified` DATETIME DEFAULT NULL,
                    PRIMARY KEY (`id`),
                    UNIQUE KEY `username` (`username`),
                    KEY `idx_user_clientId` (`clientId`)
                ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;

                INSERT INTO `zp_user`(`id`,`username`,`firstname`,`lastname`,`phone`,`profileId`,`lastlogin`,`lastpwd_change`,`status`,`expires`,`role`,`session`,`sessiontime`,`wage`,`hours`,`description`,`clientId`, `notifications`, `createdOn`, `pwReset`)
                VALUES (1,:email,:firstname,:lastname,'','',NULL,0,'i',NULL,'50','','',0,0,NULL,0,1, :createdOn, :pwReset);

                CREATE TABLE `zp_sprints` (
                    `id` INT NOT NULL AUTO_INCREMENT,
                    `projectId` INT NULL,
                    `name` VARCHAR(45) NULL,
                    `startDate` DATETIME NULL,
                    `endDate` DATETIME NULL,
                    `modified` datetime DEFAULT NULL,
                    PRIMARY KEY (`id`),
                    KEY `idx_sprints_projectId_startDate_endDate` (`projectId`, `startDate`, `endDate`)
                ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;

                CREATE TABLE `zp_stats` (
                    `sprintId` INT NULL,
                    `projectId` INT NULL,
                    `date` DATETIME NULL,
                    `sum_todos` INT NULL,
                    `sum_open_todos` INT NULL,
                    `sum_progres_todos` INT NULL,
                    `sum_closed_todos` INT NULL,
                    `sum_planned_hours` FLOAT NULL,
                    `sum_estremaining_hours` FLOAT NULL,
                    `sum_logged_hours` FLOAT NULL,
                    `sum_points` INT NULL,
                    `sum_points_done` INT NULL,
                    `sum_points_progress` INT NULL,
                    `sum_points_open` INT NULL,
                    `sum_todos_xs` INT NULL,
                    `sum_todos_s` INT NULL,
                    `sum_todos_m` INT NULL,
                    `sum_todos_l` INT NULL,
                    `sum_todos_xl` INT NULL,
                    `sum_todos_xxl` INT NULL,
                    `sum_todos_none` INT NULL,
                    `tickets` TEXT NULL,
                    `daily_avg_hours_booked_todo` FLOAT NULL,
                    `daily_avg_hours_booked_point` FLOAT NULL,
                    `daily_avg_hours_planned_todo` FLOAT NULL,
                    `daily_avg_hours_planned_point` FLOAT NULL,
                    `daily_avg_hours_remaining_point` FLOAT NULL,
                    `daily_avg_hours_remaining_todo` FLOAT NULL,
                    `sum_teammembers` INT NULL,
                    INDEX `projectId` (`projectId` ASC, `sprintId` ASC),
                    KEY `idx_stats_projectId_sprintId_date` (`projectId`, `sprintId`, `date`),
                    KEY `idx_stats_sprintId_date` (`sprintId`, `date`)
                ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;

                CREATE TABLE `zp_settings` (
                    `key` VARCHAR(175) NOT NULL,
                    `value` MEDIUMTEXT NULL,
                    PRIMARY KEY (`key`),
                    KEY `idx_settings_key` (`key`)
                ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;

                INSERT INTO zp_settings (`key`, `value`) VALUES ('db-version', :dbVersion);
                INSERT INTO zp_settings (`key`, `value`) VALUES ('companysettings.telemetry.active', 'true');

                CREATE TABLE `zp_audit` (
                    `id` INT NOT NULL AUTO_INCREMENT,
                    `userId` INT NULL,
                    `projectId` INT NULL,
                    `action` VARCHAR(45) NULL,
                    `entity` VARCHAR(45) NULL,
                    `entityId` INT NULL,
                    `values` TEXT NULL,
                    `date` DATETIME NULL,
                    PRIMARY KEY (`id`),
                    KEY `projectId` (`projectId` ASC),
                    KEY `projectAction` (`projectId` ASC, `action` ASC),
                    KEY `projectEntityEntityId` (`projectId` ASC, `entity` ASC, `entityId` ASC)
                ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;

                CREATE TABLE `zp_queue` (
                    `msghash` varchar(50) COLLATE utf8mb4_unicode_ci NOT NULL,
                    `channel` varchar(255) COLLATE utf8mb4_unicode_ci DEFAULT NULL,
                    `userId` int(11) NOT NULL,
                    `subject` varchar(255) COLLATE utf8mb4_unicode_ci DEFAULT NULL,
                    `message` text COLLATE utf8mb4_unicode_ci NOT NULL,
                    `thedate` datetime NOT NULL,
                    `projectId` int(11) NOT NULL,
                    PRIMARY KEY (`msghash`),
                    KEY `projectId` (`projectId`),
                    KEY `userId` (`userId`)
                ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;

                CREATE TABLE `zp_plugins` (
                    `id` INT NOT NULL AUTO_INCREMENT,
                    `name` VARCHAR(45) NULL,
                    `enabled` TINYINT NULL,
                    `description` VARCHAR(255) NULL,
                    `version` VARCHAR(45) NULL,
                    `installdate` DATETIME NULL,
                    `foldername` VARCHAR(45),
                    `homepage` VARCHAR(255) NULL,
                    `authors` VARCHAR(255) NULL,
                    `license` TEXT NULL DEFAULT NULL,
                    `format` VARCHAR(45) NULL DEFAULT NULL,
                    PRIMARY KEY (`id`)
                  ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;

                CREATE TABLE `zp_notifications` (
                    `id` INT NOT NULL AUTO_INCREMENT,
                    `userId` INT NOT NULL,
                    `read` INT NULL,
                    `type` VARCHAR(45) NULL,
                    `module` VARCHAR(45) NULL,
                    `moduleId` INT NULL,
                    `datetime` DATETIME NULL,
                    `url` VARCHAR(255) NULL,
                    `authorId` INT NULL,
                    `message` TEXT NULL,
                    PRIMARY KEY (`id`),
                    INDEX `userId` (`userId` ASC),
                    INDEX `userId,datetime` (`userId` ASC, `datetime` DESC),
                    INDEX `userId,read` (`userId` ASC, `read` DESC)
                  ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;

                CREATE TABLE `zp_entity_relationship` (
                    `id` INT NOT NULL AUTO_INCREMENT,
                    `entityA` INT NULL,
                    `entityAType` VARCHAR(45) NULL,
                    `entityB` INT NULL,
                    `entityBType` VARCHAR(45) NULL,
                    `relationship` VARCHAR(45) NULL,
                    `createdOn` DATETIME NULL,
                    `createdBy` INT NULL,
                    `meta` TEXT NULL,
                    PRIMARY KEY (`id`),
                    INDEX `entityA` (`entityA` ASC, `entityAType` ASC, `relationship` ASC),
                    INDEX `entityB` (`entityB` ASC, `entityBType` ASC, `relationship` ASC)
                ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;

                CREATE TABLE `zp_integration` (
                    `id` INT NOT NULL AUTO_INCREMENT,
                    `providerId` VARCHAR(45) NULL,
                    `method` VARCHAR(45) NULL,
                    `entity` VARCHAR(45) NULL,
                    `fields` TEXT NULL,
                    `schedule` VARCHAR(45) NULL,
                    `notes` VARCHAR(45) NULL,
                    `auth` TEXT NULL,
                    `meta` VARCHAR(45) NULL,
                    `createdOn` DATETIME NULL,
                    `createdBy` INT NULL,
                    `lastSync` VARCHAR(45) NULL,
                    PRIMARY KEY (`id`)
                ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;

                CREATE TABLE `zp_reactions` (
                    `id` INT NOT NULL AUTO_INCREMENT,
                    `userId` INT NULL,
                    `moduleId` INT NULL,
                    `module` VARCHAR(45) NULL,
                    `reaction` VARCHAR(45) NULL,
                    `date` DATETIME NULL,
                    PRIMARY KEY (`id`),
                    INDEX `entity` (`moduleId` ASC, `module` ASC, `reaction` ASC),
                    INDEX `user` (`userId` ASC, `moduleId` ASC, `module` ASC, `reaction` ASC)
                ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;

                CREATE TABLE `zp_access_tokens` (
                    `id` bigint unsigned NOT NULL AUTO_INCREMENT,
                    `tokenable_type` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NOT NULL,
                    `tokenable_id` bigint unsigned NOT NULL,
                    `name` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NOT NULL,
                    `token` varchar(64) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NOT NULL,
                    `abilities` text CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci,
                    `last_used_at` timestamp NULL DEFAULT NULL,
                    `expires_at` timestamp NULL DEFAULT NULL,
                    `created_at` timestamp NULL DEFAULT NULL,
                    `updated_at` timestamp NULL DEFAULT NULL,
                    PRIMARY KEY (`id`),
                    UNIQUE KEY `personal_access_tokens_token_unique` (`token`),
                    KEY `personal_access_tokens_tokenable_type_tokenable_id_index` (`tokenable_type`,`tokenable_id`)
                ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;

                CREATE TABLE `zp_jobs` (
                    `id` bigint unsigned NOT NULL AUTO_INCREMENT,
                    `queue` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NOT NULL,
                    `payload` longtext CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NOT NULL,
                    `attempts` tinyint unsigned NOT NULL,
                    `reserved_at` int unsigned DEFAULT NULL,
                    `available_at` int unsigned NOT NULL,
                    `created_at` int unsigned NOT NULL,
                    PRIMARY KEY (`id`),
                    KEY `zp_jobs_queue_index` (`queue`)
                ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;

                CREATE TABLE IF NOT EXISTS `zp_recurring_patterns` (
                    `id` INT NOT NULL AUTO_INCREMENT,
                    `entityId` INT NOT NULL,
                    `module` VARCHAR(50) NOT NULL,
                    `type` VARCHAR(50) NOT NULL,
                    `trigger` VARCHAR(50) NOT NULL,
                    `interval` INT NOT NULL DEFAULT 1,
                    `weekDays` TEXT NULL,
                    `monthDay` INT NULL,
                    `months` TEXT NULL,
                    `action` VARCHAR(20) NOT NULL DEFAULT 'reset',
                    `lastProcessed` DATETIME NULL,
                    `nextProcessingDate` DATETIME NULL,
                    `enabled` TINYINT(1) NOT NULL DEFAULT 1,
                    PRIMARY KEY (`id`),
                    INDEX `entityId` (`entityId`)
                ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;

            ";

        return $sql;
    }

    /**
     * update_sql_20004 - database update sql for V2.0.4
     * - Updates all tables and db to utf8mb4
     * - converts 255 index to be smaller
     *
     * @noinspection SqlResolve - A lot of tables don't exist anymore, so this will not resolve. Keeping the update script for backwards compatibility
     */
    private function update_sql_20004(): bool|array
    {

        $errors = [];

        $sql = [
            'ALTER TABLE `zp_wiki_articles` CONVERT TO CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;',
            'ALTER TABLE `zp_submodulerights` CONVERT TO CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;',
            'ALTER TABLE `zp_canvas` CONVERT TO CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;',
            'ALTER TABLE `zp_wiki_categories` CONVERT TO CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;',
            'ALTER TABLE `zp_tickethistory` CONVERT TO CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;',
            'ALTER TABLE `zp_gcallinks` CONVERT TO CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;',
            'ALTER TABLE `zp_message` CONVERT TO CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;',
            'ALTER TABLE `zp_note` CONVERT TO CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;',
            'ALTER TABLE `zp_timesheets` MODIFY kind VARCHAR(175);',
            'ALTER TABLE `zp_timesheets` CONVERT TO CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;',
            'ALTER TABLE `zp_roles` CONVERT TO CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;',
            'ALTER TABLE `zp_projects` CONVERT TO CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;',
            'ALTER TABLE `zp_modulerights` CONVERT TO CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;',
            'ALTER TABLE `zp_wiki_comments` CONVERT TO CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;',
            'ALTER TABLE `zp_punch_clock` CONVERT TO CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;',
            'ALTER TABLE `zp_clients` CONVERT TO CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;',
            'ALTER TABLE `zp_account` CONVERT TO CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;',
            'ALTER TABLE `zp_sprints` CONVERT TO CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;',
            'ALTER TABLE `zp_lead` CONVERT TO CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;',
            'ALTER TABLE `zp_user` MODIFY username VARCHAR(175);',
            'ALTER TABLE `zp_user` CONVERT TO CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;',
            'ALTER TABLE `zp_settings` MODIFY `key` VARCHAR(175);',
            'ALTER TABLE `zp_settings` CONVERT TO CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;',
            'ALTER TABLE `zp_comment` CONVERT TO CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;',
            'ALTER TABLE `zp_stats` CONVERT TO CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;',
            'ALTER TABLE `zp_tickets` CONVERT TO CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;',
            'ALTER TABLE `zp_canvas_items` CONVERT TO CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;',
            'ALTER TABLE `zp_dashboard_widgets` CONVERT TO CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;',
            'ALTER TABLE `zp_file` CONVERT TO CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;',
            'ALTER TABLE `zp_action_tabs` CONVERT TO CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;',
            'ALTER TABLE `zp_relationuserproject` CONVERT TO CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;',
            'ALTER TABLE `zp_calendar` CONVERT TO CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;',
            'ALTER TABLE `zp_read` CONVERT TO CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;',
            'ALTER TABLE `zp_wiki` CONVERT TO CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;',
        ];

        foreach ($sql as $statement) {
            try {
                $this->connection->statement($statement);
            } catch (\Exception $e) {
                Log::error($statement.' Failed:'.$e->getMessage());
                Log::error($e);
                array_push($errors, $statement.' Failed:'.$e->getMessage());
            }
        }

        if (count($errors) > 0) {
            return $errors;
        } else {
            return true;
        }
    }

    private function update_sql_20100(): bool|array
    {

        $errors = [];

        $sql = [
            'UPDATE `zp_user` SET role = 50 WHERE role = 2;',
            'UPDATE `zp_user` SET role = 10 WHERE role = 3;',
            'UPDATE `zp_user` SET role = 20 WHERE role = 4;',
            'UPDATE `zp_user` SET role = 40 WHERE role = 5;',
        ];

        foreach ($sql as $statement) {
            try {
                $this->connection->statement($statement);
            } catch (\Exception $e) {
                Log::error($statement.' Failed:'.$e->getMessage());
                Log::error($e);
                array_push($errors, $statement.' Failed:'.$e->getMessage());
            }
        }

        if (count($errors) > 0) {
            return $errors;
        } else {
            return true;
        }
    }

    private function update_sql_20101(): bool|array
    {

        $errors = [];

        $sql = [
            'ALTER TABLE `zp_comment` CHANGE COLUMN `module` `module` VARCHAR(200) NULL DEFAULT NULL ;',
            'ALTER TABLE `zp_stats`
                    ADD COLUMN `sum_teammembers` INT(11) NULL DEFAULT NULL AFTER `daily_avg_hours_remaining_todo`,
                    CHANGE COLUMN `sum_planned_hours` `sum_planned_hours` FLOAT NULL DEFAULT NULL ,
                    CHANGE COLUMN `sum_logged_hours` `sum_logged_hours` FLOAT NULL DEFAULT NULL ,
                    CHANGE COLUMN `sum_estremaining_hours` `sum_estremaining_hours` FLOAT NULL DEFAULT NULL ,
                    CHANGE COLUMN `daily_avg_hours_booked_todo` `daily_avg_hours_booked_todo` FLOAT NULL DEFAULT NULL ,
                    CHANGE COLUMN `daily_avg_hours_booked_point` `daily_avg_hours_booked_point` FLOAT NULL DEFAULT NULL ,
                    CHANGE COLUMN `daily_avg_hours_planned_todo` `daily_avg_hours_planned_todo` FLOAT NULL DEFAULT NULL ,
                    CHANGE COLUMN `daily_avg_hours_planned_point` `daily_avg_hours_planned_point` FLOAT NULL DEFAULT NULL ,
                    CHANGE COLUMN `daily_avg_hours_remaining_point` `daily_avg_hours_remaining_point` FLOAT NULL DEFAULT NULL ,
                    CHANGE COLUMN `daily_avg_hours_remaining_todo` `daily_avg_hours_remaining_todo` FLOAT NULL DEFAULT NULL ;',
            'CREATE TABLE `zp_audit` (
                      `id` INT NOT NULL AUTO_INCREMENT,
                      `userId` INT NULL,
                      `projectId` INT NULL,
                      `action` VARCHAR(45) NULL,
                      `entity` VARCHAR(45) NULL,
                      `entityId` INT NULL,
                      `values` TEXT NULL,
                      `date` DATETIME NULL,
                      PRIMARY KEY (`id`),
                      KEY `projectId` (`projectId` ASC),
                      KEY `projectAction` (`projectId` ASC, `action` ASC),
                      KEY `projectEntityEntityId` (`projectId` ASC, `entity` ASC, `entityId` ASC)
                    ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;',
        ];

        foreach ($sql as $statement) {
            try {
                $this->connection->statement($statement);
            } catch (\Exception $e) {
                Log::error($statement.' Failed:'.$e->getMessage());
                Log::error($e);
                array_push($errors, $statement.' Failed:'.$e->getMessage());
            }
        }

        if (count($errors) > 0) {
            return $errors;
        } else {
            return true;
        }
    }

    private function update_sql_20102(): bool|array
    {
        $errors = [];

        $sql = [
            "ALTER TABLE `zp_user` add COLUMN `twoFAEnabled` tinyint(1) DEFAULT '0'",
            'ALTER TABLE `zp_user` add COLUMN `twoFASecret` varchar(200) DEFAULT NULL',
        ];

        foreach ($sql as $statement) {
            try {
                $this->connection->statement($statement);
            } catch (\Exception $e) {
                Log::error($statement.' Failed:'.$e->getMessage());
                Log::error($e);
                array_push($errors, $statement.' Failed:'.$e->getMessage());
            }
        }

        if (count($errors) > 0) {
            return $errors;
        } else {
            return true;
        }
    }

    private function update_sql_20103(): bool|array
    {
        $errors = [];

        $sql = [
            'ALTER TABLE `zp_tickets` CHANGE COLUMN `planHours` `planHours` FLOAT NULL DEFAULT NULL',
            'ALTER TABLE `zp_tickets` CHANGE COLUMN `hourRemaining` `hourRemaining` FLOAT NULL DEFAULT NULL',
        ];

        foreach ($sql as $statement) {
            try {
                $this->connection->statement($statement);
            } catch (\Exception $e) {
                Log::error($statement.' Failed:'.$e->getMessage());
                Log::error($e);
                array_push($errors, $statement.' Failed:'.$e->getMessage());
            }
        }

        if (count($errors) > 0) {
            return $errors;
        } else {
            return true;
        }
    }

    private function update_sql_20104(): bool|array
    {
        $errors = [];

        $sql = [
            'ALTER TABLE `zp_user` ADD COLUMN `pwResetCount` INT(5) NULL AFTER `pwResetExpiration`',
            'ALTER TABLE `zp_user` ADD COLUMN `forcePwReset` TINYINT NULL AFTER `pwResetCount`',
            'ALTER TABLE `zp_user` ADD COLUMN `createdOn` DATETIME NULL AFTER `twoFASecret`',
            'ALTER TABLE `zp_user` CHANGE COLUMN `lastpwd_change` `lastpwd_change` DATETIME NULL DEFAULT NULL AFTER `forcePwReset`',
            'ALTER TABLE `zp_user` CHANGE COLUMN `expires` `expires` DATETIME NULL DEFAULT NULL',
        ];

        foreach ($sql as $statement) {
            try {
                $this->connection->statement($statement);
            } catch (\Exception $e) {
                Log::error($statement.' Failed:'.$e->getMessage());
                Log::error($e);
                array_push($errors, $statement.' Failed:'.$e->getMessage());
            }
        }

        if (count($errors) > 0) {
            return $errors;
        } else {
            return true;
        }
    }

    private function update_sql_20105(): bool|array
    {
        $errors = [];

        $sql = [
            'ALTER TABLE `zp_projects` ADD COLUMN `psettings` MEDIUMTEXT NULL AFTER `active`',
        ];

        foreach ($sql as $statement) {
            try {
                $this->connection->statement($statement);
            } catch (\Exception $e) {
                Log::error($statement.' Failed:'.$e->getMessage());
                Log::error($e);
                array_push($errors, $statement.' Failed:'.$e->getMessage());
            }
        }

        if (count($errors) > 0) {
            return $errors;
        } else {
            return true;
        }
    }

    private function update_sql_20106(): bool|array
    {
        $errors = [];

        $sql = [
            'ALTER TABLE `zp_user` ADD COLUMN `source` varchar(200) DEFAULT NULL',
        ];

        foreach ($sql as $statement) {
            try {
                $this->connection->statement($statement);
            } catch (\Exception $e) {
                Log::error($statement.' Failed:'.$e->getMessage());
                Log::error($e);
                array_push($errors, $statement.' Failed:'.$e->getMessage());
            }
        }

        if (count($errors) > 0) {
            return $errors;
        } else {
            return true;
        }
    }

    private function update_sql_20107(): bool|array
    {
        $errors = [];

        $sql = [
            "INSERT INTO zp_settings (`key`, `value`) VALUES ('companysettings.telemetry.active', 'true')",
        ];

        foreach ($sql as $statement) {
            try {
                $this->connection->statement($statement);
            } catch (\Exception $e) {
                Log::error($statement.' Failed:'.$e->getMessage());
                Log::error($e);
                array_push($errors, $statement.' Failed:'.$e->getMessage());
            }
        }

        if (count($errors) > 0) {
            return $errors;
        } else {
            return true;
        }
    }

    private function update_sql_20108(): bool|array
    {
        $errors = [];

        $sql = [
            'alter table zp_relationuserproject add `projectRole` varchar(20) null',
            'create index zp_relationuserproject_projectId_index on zp_relationuserproject (projectId)',
            'create index zp_relationuserproject_userId_index on zp_relationuserproject (userId)',
        ];

        foreach ($sql as $statement) {
            try {
                $this->connection->statement($statement);
            } catch (\Exception $e) {
                Log::error($statement.' Failed:'.$e->getMessage());
                Log::error($e);
                array_push($errors, $statement.' Failed:'.$e->getMessage());
            }
        }

        if (count($errors) > 0) {
            return $errors;
        } else {
            return true;
        }
    }

    private function update_sql_20109(): bool|array
    {

        $errors = [];

        $sql = [
            'CREATE TABLE IF NOT EXISTS `zp_queue` (
                               `msghash` varchar(50) NOT NULL,
                                `channel` varchar(255),
                               `userId` int(11) NOT NULL,
                                `subject` varchar(255),
                               `message` text NOT NULL,
                               `thedate` datetime NOT NULL,
                               `projectId` int(11) NOT NULL,
                               PRIMARY KEY (`msghash`),
                               KEY `projectId` (`projectId`),
                               KEY `userId` (`userId`)
			   ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;',
        ];

        foreach ($sql as $statement) {
            try {
                $this->connection->statement($statement);
            } catch (\Exception $e) {
                Log::error($statement.' Failed:'.$e->getMessage());
                Log::error($e);
                array_push($errors, $statement.' Failed:'.$e->getMessage());
            }
        }

        if (count($errors) > 0) {
            return $errors;
        } else {
            return true;
        }
    }

    private function update_sql_20110(): bool|array
    {

        $errors = [];

        $sql = [
            'alter table zp_canvas_items add tags text null',
            'alter table zp_canvas_items add title varchar(255) null',
            'alter table zp_canvas_items add parent int null',
            'alter table zp_canvas_items add featured int null',
            'create table zp_approvals
                (
                    id               int auto_increment,
                    module           varchar(100) null,
                    entityId         int          null,
                    requestorId      int          null,
                    approverId       int          null,
                    approvalStatus   int          null,
                    requestedOn      datetime     null,
                    lastStatusChange datetime     null,
                    constraint zp_approvals_pk
                        primary key (id)
                )',
            'alter table zp_comment add status varchar(50) null',
        ];

        foreach ($sql as $statement) {
            try {
                $this->connection->statement($statement);
            } catch (\Exception $e) {
                Log::error($statement.' Failed:'.$e->getMessage());
                Log::error($e);
                array_push($errors, $statement.' Failed:'.$e->getMessage());
            }
        }

        if (count($errors) > 0) {
            return $errors;
        } else {
            return true;
        }
    }

    /*         * *
     * update_sql_20111 - Update database for new Canvas
     *
     * @access private
     * @return bool|array    Success of database update or array of errors
     */

    private function update_sql_20111(): bool|array
    {

        $errors = [];

        $sql = [
            'ALTER TABLE zp_projects ADD menuType MEDIUMTEXT null',
            "UPDATE zp_projects SET menuType = '".MenuRepository::DEFAULT_MENU."'",
            'ALTER TABLE zp_canvas_items ADD relates VARCHAR(255) null',
            'UPDATE zp_canvas_items INNER JOIN zp_canvas ON zp_canvas.id = zp_canvas_items.id '.
            "SET zp_canvas_items.status = 'draft' WHERE zp_canvas_items.status = 'danger' AND zp_canvas.type = 'leancanvas'",
            'UPDATE zp_canvas_items INNER JOIN zp_canvas ON zp_canvas.id = zp_canvas_items.id '.
            "SET zp_canvas_items.status = 'valid' WHERE zp_canvas_items.status = 'sucess' AND zp_canvas.type = 'leancanvas'",
            'UPDATE zp_canvas_items INNER JOIN zp_canvas ON zp_canvas.id = zp_canvas_items.id '.
            "SET zp_canvas_items.status = 'invalid' WHERE zp_canvas_items.status = 'info' AND zp_canvas.type = 'leancanvas'",
            "UPDATE zp_canvas SET zp_canvas.type = 'retroscanvas' WHERE zp_canvas.type = 'retrospective'",
        ];

        foreach ($sql as $statement) {
            try {
                $this->connection->statement($statement);
            } catch (\Exception $e) {
                Log::error($statement.' Failed:'.$e->getMessage());
                Log::error($e);
                array_push($errors, $statement.' Failed:'.$e->getMessage());
            }
        }

        if (count($errors) > 0) {
            return $errors;
        } else {
            return true;
        }
    }

    /*         * *
     * update_sql_20112 - Update database for new Canvas
     *
     * @access private
     * @return bool|array    Success of database update or array of errors
     */

    private function update_sql_20112(): bool|array
    {

        $errors = [];

        $sql = [
            'CREATE TABLE `zp_plugins` (
                  `id` INT NOT NULL AUTO_INCREMENT,
                  `name` VARCHAR(45) NULL,
                  `enabled` TINYINT NULL,
                  `description` VARCHAR(255) NULL,
                  `version` VARCHAR(45) NULL,
                  `installdate` DATETIME NULL,
                  `foldername` VARCHAR(45) NULL,
                  `homepage` VARCHAR(255) NULL,
                  `authors` VARCHAR(255) NULL,
                  PRIMARY KEY (`id`)
                ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;',
            'ALTER TABLE `zp_timesheets` ADD COLUMN `paid` SMALLINT NULL AFTER `rate`, ADD COLUMN `paidDate` DATETIME NULL AFTER `paid`;',
            'DROP TABLE IF EXISTS zp_account, zp_action_tabs, zp_dashboard_widgets, zp_lead, zp_message, zp_modulerights, zp_roles, zp_submodulerights, zp_wiki, zp_wiki_articles, zp_wiki_categories, zp_wiki_comments;',
            'CREATE TABLE `zp_notifications` (
                  `id` INT NOT NULL AUTO_INCREMENT,
                  `userId` INT NOT NULL,
                  `read` INT NULL,
                  `type` VARCHAR(45) NULL,
                  `module` VARCHAR(45) NULL,
                  `moduleId` INT NULL,
                  `datetime` DATETIME NULL,
                  `url` VARCHAR(255) NULL,
                  `authorId` INT NULL,
                  `message` TEXT NULL,
                  PRIMARY KEY (`id`),
                  INDEX `userId` (`userId` ASC),
                  INDEX `userId,datetime` (`userId` ASC, `datetime` DESC),
                  INDEX `userId,read` (`userId` ASC, `read` DESC)
                  ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;',
        ];

        foreach ($sql as $statement) {
            try {
                $this->connection->statement($statement);
            } catch (\Exception $e) {
                Log::error($statement.' Failed:'.$e->getMessage());
                Log::error($e);
                array_push($errors, $statement.' Failed:'.$e->getMessage());
            }
        }

        if (count($errors) > 0) {
            return $errors;
        } else {
            return true;
        }
    }

    /* * *
     * update_sql_20113 - Create onboarding setting for first time installs
     *
     * @access private
     * @return bool|array    Success of database update or array of errors
     */

    private function update_sql_20113(): bool|array
    {

        $errors = [];

        $sql = [
            "INSERT INTO zp_settings (`key`, `value`) VALUES ('companysettings.completedOnboarding', 'true') ON DUPLICATE KEY UPDATE `value` = 'true'",
        ];

        foreach ($sql as $statement) {
            try {
                $this->connection->statement($statement);
            } catch (\Exception $e) {
                Log::error($statement.' Failed:'.$e->getMessage());
                Log::error($e);
                array_push($errors, $statement.' Failed:'.$e->getMessage());
            }
        }

        if (count($errors) > 0) {
            return $errors;
        } else {
            return true;
        }
    }

    public function update_sql_20114(): bool|array
    {

        $errors = [];

        $sql = [
            'ALTER TABLE `zp_projects`
                ADD COLUMN `type` VARCHAR(45) NULL,
                ADD COLUMN `start` DATETIME NULL,
                ADD COLUMN `end` DATETIME NULL,
                ADD COLUMN `created` DATETIME NULL,
                ADD COLUMN `modified` DATETIME NULL',
        ];

        foreach ($sql as $statement) {
            try {
                $this->connection->statement($statement);
            } catch (\Exception $e) {
                Log::error($statement.' Failed:'.$e->getMessage());
                Log::error($e);
                array_push($errors, $statement.' Failed:'.$e->getMessage());
            }
        }

        if (count($errors) > 0) {
            return $errors;
        } else {
            return true;
        }
    }

    public function update_sql_20115(): bool|array
    {

        $errors = [];

        $sql = [
            ' CREATE TABLE `zp_entity_relationships` (
                        `id` INT NOT NULL AUTO_INCREMENT,
                        `enitityA` INT NULL,
                        `entityAType` VARCHAR(45) NULL,
                        `entityB` INT NULL,
                        `entityBType` VARCHAR(45) NULL,
                        `relationship` VARCHAR(45) NULL,
                        `createdOn` DATETIME NULL,
                        `createdBy` INT NULL,
                        `meta` TEXT NULL,
                        PRIMARY KEY (`id`),
                        INDEX `entityA` (`enitityA` ASC, `entityAType` ASC, `relationship` ASC),
                        INDEX `entityB` (`entityB` ASC, `entityBType` ASC, `relationship` ASC)
                    ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci',
            "UPDATE `zp_tickets` SET milestoneid = dependingTicketId , dependingTicketId = '' WHERE type <> 'subtask' AND dependingTicketId > 0",
        ];

        foreach ($sql as $statement) {
            try {
                $this->connection->statement($statement);
            } catch (\Exception $e) {
                Log::error($statement.' Failed:'.$e->getMessage());
                Log::error($e);
                array_push($errors, $statement.' Failed:'.$e->getMessage());
            }
        }

        if (count($errors) > 0) {
            return $errors;
        } else {
            return true;
        }
    }

    public function update_sql_20116(): bool|array
    {

        $errors = [];

        $sql = [
            ' CREATE TABLE `zp_reactions` (
                      `id` INT NOT NULL AUTO_INCREMENT,
                      `userId` INT NULL,
                      `moduleId` INT NULL,
                      `module` VARCHAR(45) NULL,
                      `reaction` VARCHAR(45) NULL,
                      `date` DATETIME NULL,
                      PRIMARY KEY (`id`),
                      INDEX `entity` (`moduleId` ASC, `module` ASC, `reaction` ASC),
                      INDEX `user` (`userId` ASC, `moduleId` ASC, `module` ASC, `reaction` ASC)
                      ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci',
            'ALTER TABLE `zp_projects`
                ADD COLUMN `avatar` MEDIUMTEXT NULL AFTER `modified`,
                ADD COLUMN `cover` MEDIUMTEXT NULL AFTER `avatar`;',

        ];

        foreach ($sql as $statement) {
            try {
                $this->connection->statement($statement);
            } catch (\Exception $e) {
                Log::error($statement.' Failed:'.$e->getMessage());
                Log::error($e);
                array_push($errors, $statement.' Failed:'.$e->getMessage());
            }
        }

        if (count($errors) > 0) {
            return $errors;
        } else {
            return true;
        }
    }

    public function update_sql_20117(): bool|array
    {

        $errors = [];

        $sql = [
            'ALTER TABLE `zp_projects`
                ADD COLUMN `parent` INT(11) NULL;',

            'ALTER TABLE `zp_projects`
                ADD COLUMN `sortIndex` INT(11) NULL;',

            'ALTER TABLE `zp_user`
                ADD COLUMN `jobTitle` VARCHAR(200) NULL ,
                ADD COLUMN `jobLevel` VARCHAR(50) NULL ,
                ADD COLUMN `department` VARCHAR(200) NULL ;',

        ];

        foreach ($sql as $statement) {
            try {
                $this->connection->statement($statement);
            } catch (\Exception $e) {
                Log::error($statement.' Failed:'.$e->getMessage());
                Log::error($e);
                array_push($errors, $statement.' Failed:'.$e->getMessage());
            }
        }

        if (count($errors) > 0) {
            return $errors;
        } else {
            return true;
        }
    }

    public function update_sql_20118(): bool|array
    {

        $errors = [];

        $sql = [

            'UPDATE `zp_projects` SET parent = null;',

            'UPDATE `zp_projects` SET start = null, end = null;',

            'ALTER TABLE `zp_projects`
                CHANGE COLUMN `parent` `parent` INT(11) NULL DEFAULT NULL,
                CHANGE COLUMN `type` `type` VARCHAR(45) NULL DEFAULT NULL ;',

        ];

        foreach ($sql as $statement) {
            try {
                $this->connection->statement($statement);
            } catch (\Exception $e) {
                Log::error($statement.' Failed:'.$e->getMessage());
                Log::error($e);
                array_push($errors, $statement.' Failed:'.$e->getMessage());
            }
        }

        if (count($errors) > 0) {
            return $errors;
        } else {
            return true;
        }
    }

    public function update_sql_20120(): bool|array
    {

        $errors = [];

        $sql = [

            'ALTER TABLE `zp_canvas_items`
                ADD COLUMN `kpi` INT NULL DEFAULT NULL AFTER `tags`,
                ADD COLUMN `data1` TEXT NULL DEFAULT NULL AFTER `kpi`,
                ADD COLUMN `data2` TEXT NULL DEFAULT NULL AFTER `data1`,
                ADD COLUMN `data3` TEXT NULL DEFAULT NULL AFTER `data2`,
                ADD COLUMN `data4` TEXT NULL DEFAULT NULL AFTER `data3`,
                ADD COLUMN `data5` TEXT NULL DEFAULT NULL AFTER `data4`,
                ADD COLUMN `startDate` DATETIME NULL DEFAULT NULL AFTER `data5`,
                ADD COLUMN `endDate` DATETIME NULL DEFAULT NULL AFTER `startDate`,
                ADD COLUMN `setting` TEXT NULL DEFAULT NULL AFTER `endDate`,
                ADD COLUMN `metricType` VARCHAR(45) NULL DEFAULT NULL AFTER `setting`,
                ADD COLUMN `startValue` double(10,2) NULL DEFAULT NULL AFTER `metricType`,
                ADD COLUMN `currentValue` double(10,2) NULL DEFAULT NULL AFTER `startValue`,
                ADD COLUMN `endValue` double(10,2) NULL DEFAULT NULL AFTER `currentValue`,
                ADD COLUMN `impact` INT NULL DEFAULT NULL AFTER `endValue`,
                ADD COLUMN `effort` INT NULL DEFAULT NULL AFTER `impact`,
                ADD COLUMN `probability` INT NULL DEFAULT NULL AFTER `effort`,
                ADD COLUMN `action` TEXT NULL DEFAULT NULL AFTER `probability`,
                ADD COLUMN `assignedTo` INT NULL DEFAULT NULL AFTER `action`;',
            "UPDATE zp_canvas_items SET
                    currentValue = CAST(CASE WHEN `data` = '' THEN 0 ELSE `data` END AS DECIMAL(10,2)),
                    endValue = CAST(CASE WHEN `conclusion` = '' THEN 0 ELSE `conclusion` END AS DECIMAL(10,2)),
                    title = description,
                    description = assumptions
                    WHERE box = 'goal';",
            'ALTER TABLE `zp_canvas_items`
                ADD INDEX `CanvasLookUp` (`canvasId` ASC, `box` ASC);',

        ];

        foreach ($sql as $statement) {
            try {
                $this->connection->statement($statement);
            } catch (\Exception $e) {
                Log::error($statement.' Failed:'.$e->getMessage());
                Log::error($e);
                array_push($errors, $statement.' Failed:'.$e->getMessage());
            }
        }

        if (count($errors) > 0) {
            return $errors;
        } else {
            return true;
        }
    }

    public function update_sql_20121(): bool|array
    {

        $errors = [];

        $sql = [
            'ALTER TABLE `zp_canvas`
                    ADD COLUMN `description` TEXT NULL DEFAULT NULL AFTER `type`;',
        ];

        foreach ($sql as $statement) {
            try {
                $this->connection->statement($statement);
            } catch (\Exception $e) {
                Log::error($statement.' Failed:'.$e->getMessage());
                Log::error($e);
                array_push($errors, $statement.' Failed:'.$e->getMessage());
            }
        }

        if (count($errors) > 0) {
            return $errors;
        } else {
            return true;
        }
    }

    public function update_sql_20122(): bool|array
    {

        $errors = [];

        $sql = [
            'ALTER TABLE `zp_settings`
                    CHANGE COLUMN `value` `value` MEDIUMTEXT NULL DEFAULT NULL ;',
            'ALTER TABLE `zp_canvas_items`
                    CHANGE COLUMN `description` `description` MEDIUMTEXT NULL DEFAULT NULL ,
                    CHANGE COLUMN `data` `data` MEDIUMTEXT NULL DEFAULT NULL;',
            'ALTER TABLE `zp_user`
                    ADD COLUMN `modified` DATETIME NULL DEFAULT NULL;',
        ];

        foreach ($sql as $statement) {
            try {
                $this->connection->statement($statement);
            } catch (\Exception $e) {
                Log::error($statement.' Failed:'.$e->getMessage());
                Log::error($e);
                array_push($errors, $statement.' Failed:'.$e->getMessage());
            }
        }

        if (count($errors) > 0) {
            return $errors;
        } else {
            return true;
        }
    }

    public function update_sql_20401(): bool|array
    {

        $errors = [];

        $sql = [
            'ALTER TABLE `zp_plugins`
                ADD COLUMN `license` TEXT NULL DEFAULT NULL,
                ADD COLUMN `format` VARCHAR(45) NULL DEFAULT NULL',
        ];

        foreach ($sql as $statement) {
            try {
                $this->connection->statement($statement);
            } catch (\Exception $e) {
                Log::error($statement.' Failed:'.$e->getMessage());
                Log::error($e);
                array_push($errors, $statement.' Failed:'.$e->getMessage());
            }
        }

        if (count($errors) > 0) {
            return $errors;
        } else {
            return true;
        }
    }

    public function update_sql_20402(): bool|array
    {
        $errors = [];

        $sql = [
            'ALTER TABLE `zp_plugins`
                ADD COLUMN `format` VARCHAR(45) NULL DEFAULT NULL',
        ];

        foreach ($sql as $statement) {
            try {
                $this->connection->statement($statement);
            } catch (\Exception $e) {
                Log::error($statement.' Failed:'.$e->getMessage());
                Log::error($e);
                $errors[] = "$statement Failed: {$e->getMessage()}";
            }
        }

        return count($errors) ? $errors : true;
    }

    /**
     * Install script did not include medium text updates. Run again
     */
    public function update_sql_20405(): bool|array
    {

        $errors = [];

        $sql = [
            'ALTER TABLE `zp_settings`
                    CHANGE COLUMN `value` `value` MEDIUMTEXT NULL DEFAULT NULL ;',
            'ALTER TABLE `zp_canvas_items`
                    CHANGE COLUMN `description` `description` MEDIUMTEXT NULL DEFAULT NULL ,
                    CHANGE COLUMN `data` `data` MEDIUMTEXT NULL DEFAULT NULL;',
        ];

        foreach ($sql as $statement) {
            try {
                $this->connection->statement($statement);
            } catch (\Exception $e) {
                Log::error($statement.' Failed:'.$e->getMessage());
                Log::error($e);
                array_push($errors, $statement.' Failed:'.$e->getMessage());
            }
        }

        if (count($errors) > 0) {
            return $errors;
        } else {
            return true;
        }
    }

    /**
     * Install script did not include medium text updates. Run again
     */
    public function update_sql_20406(): bool|array
    {

        $errors = [];

        $sql = [
            'ALTER TABLE `zp_canvas_items`
                    CHANGE COLUMN `data1` `data1` MEDIUMTEXT NULL DEFAULT NULL,
                    CHANGE COLUMN `data2` `data2` MEDIUMTEXT NULL DEFAULT NULL,
                    CHANGE COLUMN `data3` `data3` MEDIUMTEXT NULL DEFAULT NULL,
                    CHANGE COLUMN `data4` `data4` MEDIUMTEXT NULL DEFAULT NULL,
                    CHANGE COLUMN `data5` `data5` MEDIUMTEXT NULL DEFAULT NULL;',
        ];

        foreach ($sql as $statement) {
            try {
                $this->connection->statement($statement);
            } catch (\Exception $e) {
                Log::error($statement.' Failed:'.$e->getMessage());
                Log::error($e);
                array_push($errors, $statement.' Failed:'.$e->getMessage());
            }
        }

        if (count($errors) > 0) {
            return $errors;
        } else {
            return true;
        }
    }

    public function update_sql_20407(): bool|array
    {

        $errors = [];

        $sql = [
            'CREATE TABLE IF NOT EXISTS `zp_integration` (
                      `id` INT NOT NULL AUTO_INCREMENT,
                      `providerId` VARCHAR(45) NULL,
                      `method` VARCHAR(45) NULL,
                      `entity` VARCHAR(45) NULL,
                      `fields` TEXT NULL,
                      `schedule` VARCHAR(45) NULL,
                      `notes` VARCHAR(45) NULL,
                      `auth` TEXT NULL,
                      `meta` VARCHAR(45) NULL,
                      `createdOn` DATETIME NULL,
                      `createdBy` INT NULL,
                      PRIMARY KEY (`id`)
                      ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci',
            'ALTER TABLE `zp_integration`
                    ADD COLUMN `lastSync` DATETIME NULL DEFAULT NULL',
        ];

        foreach ($sql as $statement) {
            try {
                $this->connection->statement($statement);
            } catch (\Exception $e) {
                Log::error($statement.' Failed:'.$e->getMessage());
                Log::error($e);
                array_push($errors, $statement.' Failed:'.$e->getMessage());
            }
        }

        if (count($errors) > 0) {
            return $errors;
        } else {
            return true;
        }
    }

    public function update_sql_30002(): bool|array
    {

        $errors = [];

        $sql = [
            'ALTER TABLE `zp_plugins` ADD COLUMN `license` TEXT NULL DEFAULT NULL',
            'ALTER TABLE `zp_plugins` ADD COLUMN `format` VARCHAR(45) NULL DEFAULT NULL',
        ];

        foreach ($sql as $statement) {
            try {
                $this->connection->statement($statement);
            } catch (\Exception $e) {
                Log::error($statement.' Failed:'.$e->getMessage());
                Log::error($e);
            }
        }

        return true;
    }

    public function update_sql_30003(): bool|array
    {

        $errors = [];

        $sql = [
            'ALTER TABLE `zp_canvas` ADD COLUMN `modified` datetime NULL DEFAULT NULL',
            'ALTER TABLE `zp_clients` ADD COLUMN `modified` datetime NULL DEFAULT NULL',
            'ALTER TABLE `zp_sprints` ADD COLUMN `modified` datetime NULL DEFAULT NULL',
            'ALTER TABLE `zp_projects` ADD COLUMN `modified` datetime NULL DEFAULT NULL',
            'ALTER TABLE `zp_timesheets` ADD COLUMN `modified` datetime NULL DEFAULT NULL',
            'ALTER TABLE `zp_tickets` ADD COLUMN `modified` datetime NULL DEFAULT NULL',
        ];

        foreach ($sql as $statement) {
            try {
                $this->connection->statement($statement);
            } catch (\Exception $e) {
                Log::error($statement.' Failed:'.$e->getMessage());
                Log::error($e);
            }
        }

        return true;
    }

    public function update_sql_30400(): bool|array
    {

        $errors = [];

        $sql = [
            'CREATE TABLE IF NOT EXISTS `zp_access_tokens` (
                    `id` bigint unsigned NOT NULL AUTO_INCREMENT,
                    `tokenable_type` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NOT NULL,
                    `tokenable_id` bigint unsigned NOT NULL,
                    `name` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NOT NULL,
                    `token` varchar(64) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NOT NULL,
                    `abilities` text CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci,
                    `last_used_at` timestamp NULL DEFAULT NULL,
                    `expires_at` timestamp NULL DEFAULT NULL,
                    `created_at` timestamp NULL DEFAULT NULL,
                    `updated_at` timestamp NULL DEFAULT NULL,
                    PRIMARY KEY (`id`),
                    UNIQUE KEY `personal_access_tokens_token_unique` (`token`),
                    KEY `personal_access_tokens_tokenable_type_tokenable_id_index` (`tokenable_type`,`tokenable_id`)
                ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;',
            'CREATE TABLE IF NOT EXISTS `zp_jobs` (
                    `id` bigint unsigned NOT NULL AUTO_INCREMENT,
                    `queue` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NOT NULL,
                    `payload` longtext CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NOT NULL,
                    `attempts` tinyint unsigned NOT NULL,
                    `reserved_at` int unsigned DEFAULT NULL,
                    `available_at` int unsigned NOT NULL,
                    `created_at` int unsigned NOT NULL,
                    PRIMARY KEY (`id`),
                    KEY `zp_jobs_queue_index` (`queue`)
                ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;',
            'CREATE TABLE IF NOT EXISTS `zp_recurring_patterns` (
                    `id` INT NOT NULL AUTO_INCREMENT,
                    `entityId` INT NOT NULL,
                    `module` VARCHAR(50) NOT NULL,
                    `type` VARCHAR(50) NOT NULL,
                    `trigger` VARCHAR(50) NOT NULL,
                    `interval` INT NOT NULL DEFAULT 1,
                    `weekDays` TEXT NULL,
                    `monthDay` INT NULL,
                    `months` TEXT NULL,
                    `action` VARCHAR(20) NOT NULL DEFAULT \'reset\',
                    `lastProcessed` DATETIME NULL,
                    `nextProcessingDate` DATETIME NULL,
                    `enabled` TINYINT(1) NOT NULL DEFAULT 1,
                    PRIMARY KEY (`id`),
                    INDEX `entityId` (`entityId`)
                ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci',
        ];

        foreach ($sql as $statement) {
            try {
                $this->connection->statement($statement);
            } catch (\Exception $e) {
                Log::error($statement.' Failed:'.$e->getMessage());
                Log::error($e);
                $errors[] = 'Migration 30400 failed: '.$e->getMessage();
            }
        }

        // Report failures instead of returning true regardless. Swallowing them here is what
        // let installs record 3.4.0 as applied while zp_access_tokens did not exist, which
        // then broke every subsequent upgrade at 30504 (#3706). The creates above are
        // IF NOT EXISTS, so a re-run on a healthy install is still a no-op.
        if ($errors !== []) {
            return $errors;
        }

        return true;
    }

    public function update_sql_30408(): bool|array
    {

        $errors = [];

        $sql = [
            'INSERT INTO zp_settings (`key`, `value`)
                    SELECT
                        CONCAT("user.", `id`, ".firstLoginComplete") AS `key`,
                        1 AS `value`
                    FROM zp_user;',

        ];

        foreach ($sql as $statement) {
            try {
                $this->connection->statement($statement);
            } catch (\Exception $e) {
                Log::error($statement.' Failed:'.$e->getMessage());
                Log::error($e);
            }
        }

        return true;
    }

    /**
     * Database performance optimization - add indexes for frequently used queries
     */
    public function update_sql_30409(): bool|array
    {
        $errors = [];

        // High Priority Indexes - Critical Performance Impact
        $sql = [
            // Individual column indexes for tickets table
            'CREATE INDEX idx_tickets_editorId ON zp_tickets (editorId)',
            'CREATE INDEX idx_tickets_milestoneid ON zp_tickets (milestoneid)',
            'CREATE INDEX idx_tickets_editFrom ON zp_tickets (editFrom)',
            'CREATE INDEX idx_tickets_editTo ON zp_tickets (editTo)',
            'CREATE INDEX idx_tickets_dateToFinish ON zp_tickets (dateToFinish)',
            'CREATE INDEX idx_tickets_modified ON zp_tickets (modified)',

            // Medium Priority - Combined indexes for common filter patterns
            'CREATE INDEX idx_tickets_projectId_status ON zp_tickets (projectId, status)',
            'CREATE INDEX idx_tickets_projectId_type ON zp_tickets (projectId, type)',

            // User and project related indexes
            'CREATE INDEX idx_user_clientId ON zp_user (clientId)',
            'CREATE INDEX idx_projects_clientId ON zp_projects (clientId)',
            'CREATE INDEX idx_projects_state ON zp_projects (state)',

            // Timesheets performance
            'CREATE INDEX idx_timesheets_ticketId ON zp_timesheets (ticketId)',

            // Lower Priority - Additional combinations
            'CREATE INDEX idx_tickets_status_type ON zp_tickets (status, type)',
            'CREATE INDEX idx_tickethistory_ticketId_dateModified ON zp_tickethistory (ticketId, dateModified)',

            // Phase 2: Canvas, Comments, Files, Notifications, Calendar, Sprints Performance
            // Canvas and Canvas Items - High Priority for Ideas, Goals, Wiki
            'CREATE INDEX idx_canvas_projectId_type ON zp_canvas (projectId, type)',
            'CREATE INDEX idx_canvas_type_id ON zp_canvas (type, id)',
            'CREATE INDEX idx_canvas_items_canvasId_box ON zp_canvas_items (canvasId, box)',
            'CREATE INDEX idx_canvas_items_box_milestoneId ON zp_canvas_items (box, milestoneId)',
            'CREATE INDEX idx_canvas_items_box_status_author ON zp_canvas_items (box, status, author)',
            'CREATE INDEX idx_canvas_items_parent_title ON zp_canvas_items (parent, title)',

            // Notifications - High Priority for user interactions
            'CREATE INDEX idx_notifications_userId_read_datetime ON zp_notifications (userId, `read`, datetime)',

            // Timesheets - Additional High Priority indexes
            'CREATE INDEX idx_timesheets_userId_workDate ON zp_timesheets (userId, workDate)',
            'CREATE INDEX idx_timesheets_ticketId_workDate ON zp_timesheets (ticketId, workDate)',

            // Calendar - High Priority for scheduling
            'CREATE INDEX idx_calendar_userId_dateFrom_dateTo ON zp_calendar (userId, dateFrom, dateTo)',
            'CREATE INDEX idx_gcallinks_userId ON zp_gcallinks (userId)',

            // Comments - Medium Priority for threaded discussions
            'CREATE INDEX idx_comment_moduleId_module_commentParent ON zp_comment (moduleId, module, commentParent)',
            'CREATE INDEX idx_comment_userId_module ON zp_comment (userId, module)',

            // Files - Medium Priority for file access
            'CREATE INDEX idx_file_module_moduleId_userId ON zp_file (module, moduleId, userId)',

            // Sprints - Medium Priority for project management
            'CREATE INDEX idx_sprints_projectId_startDate_endDate ON zp_sprints (projectId, startDate, endDate)',

            // Settings - For project configuration lookups
            'CREATE INDEX idx_settings_key ON zp_settings (`key`)',

            // Stats table for reports (if exists) - Lower Priority
            'CREATE INDEX idx_stats_projectId_sprintId_date ON zp_stats (projectId, sprintId, date)',
            'CREATE INDEX idx_stats_sprintId_date ON zp_stats (sprintId, date)',
        ];

        foreach ($sql as $statement) {
            try {
                $this->connection->statement($statement);
            } catch (\Exception $e) {
                Log::error($statement.' Failed:'.$e->getMessage());
                Log::error($e);
                // Don't fail the entire migration for duplicate indexes
                if (! str_contains($e->getMessage(), 'Duplicate key name')) {
                    array_push($errors, $statement.' Failed:'.$e->getMessage());
                }
            }
        }

        return count($errors) ? $errors : true;
    }

    /**
     * Migration 30410: Ensure zp_entity_relationship table exists with correct schema
     *
     * This migration must handle all possible database states from different upgrade paths:
     * - State A: Only plural table (zp_entity_relationships) exists with typo column (enitityA)
     * - State B: Only singular table (zp_entity_relationship) exists with correct column (entityA)
     * - State C: Only singular table exists with typo column (enitityA)
     * - State D: Both tables exist (from failed previous migrations)
     * - State E: Neither table exists (fresh install edge case)
     *
     * @return bool Always returns true to prevent blocking subsequent migrations
     */
    public function update_sql_30410(): bool|array
    {
        $pluralTable = 'zp_entity_relationships';
        $singularTable = 'zp_entity_relationship';

        try {
            $pluralExists = $this->tableExistsForMigration($pluralTable);
            $singularExists = $this->tableExistsForMigration($singularTable);

            // Case D: Both tables exist - merge data from plural into singular, then drop plural
            if ($pluralExists && $singularExists) {
                $this->mergeEntityRelationshipTables($pluralTable, $singularTable);
            }
            // Case A: Only plural exists - rename to singular
            elseif ($pluralExists) {
                $this->connection->statement("RENAME TABLE `{$pluralTable}` TO `{$singularTable}`");
            }
            // Case E: Neither exists - create singular with correct schema (plural already ruled out above)
            elseif (! $singularExists) {
                $this->createEntityRelationshipTable();

                return true;
            }
            // Case B/C: Only singular exists - continue to fix column/index if needed

            // Fix column typo if present (handles Case A after rename, Case C, Case D after merge)
            $this->fixEntityAColumnTypo($singularTable);

            // Ensure correct index exists
            $this->ensureEntityAIndex($singularTable);

        } catch (\Exception $e) {
            Log::error('Migration 30410: '.$e->getMessage());
            // Don't fail the migration - log and continue
        }

        return true;
    }

    /**
     * Check if a table exists in the current database
     */
    private function tableExistsForMigration(string $tableName): bool
    {
        $result = $this->connection->select(
            'SELECT COUNT(*) as cnt FROM information_schema.tables
             WHERE table_schema = DATABASE() AND table_name = ?',
            [$tableName]
        );

        return $result[0]->cnt > 0;
    }

    /**
     * Check if a column exists in a table
     */
    private function columnExistsForMigration(string $tableName, string $columnName): bool
    {
        $result = $this->connection->select(
            'SELECT COUNT(*) as cnt FROM information_schema.columns
             WHERE table_schema = DATABASE() AND table_name = ? AND column_name = ?',
            [$tableName, $columnName]
        );

        return $result[0]->cnt > 0;
    }

    /**
     * Check if an index exists on a table
     */
    private function indexExistsForMigration(string $tableName, string $indexName): bool
    {
        $result = $this->connection->select(
            'SELECT COUNT(*) as cnt FROM information_schema.statistics
             WHERE table_schema = DATABASE() AND table_name = ? AND index_name = ?',
            [$tableName, $indexName]
        );

        return $result[0]->cnt > 0;
    }

    /**
     * Merge data from plural table into singular table, then drop plural
     */
    private function mergeEntityRelationshipTables(string $sourceTable, string $targetTable): void
    {
        try {
            // Determine column names in source table (may have typo)
            $sourceHasTypo = $this->columnExistsForMigration($sourceTable, 'enitityA');
            $sourceEntityAColumn = $sourceHasTypo ? 'enitityA' : 'entityA';

            // Determine column names in target table (may have typo)
            $targetHasTypo = $this->columnExistsForMigration($targetTable, 'enitityA');
            $targetEntityAColumn = $targetHasTypo ? 'enitityA' : 'entityA';

            // Insert data from source into target, ignoring duplicates
            $this->connection->statement("
                INSERT IGNORE INTO `{$targetTable}` (
                    `{$targetEntityAColumn}`, `entityAType`, `entityB`, `entityBType`,
                    `relationship`, `createdOn`, `createdBy`, `meta`
                )
                SELECT
                    `{$sourceEntityAColumn}`, `entityAType`, `entityB`, `entityBType`,
                    `relationship`, `createdOn`, `createdBy`, `meta`
                FROM `{$sourceTable}`
            ");

            // Drop the source (plural) table
            $this->connection->statement("DROP TABLE `{$sourceTable}`");

        } catch (\Exception $e) {
            Log::error('Migration 30410: Failed to merge tables: '.$e->getMessage());
        }
    }

    /**
     * Create the entity_relationship table with correct schema
     */
    private function createEntityRelationshipTable(): void
    {
        $this->connection->statement('
            CREATE TABLE `zp_entity_relationship` (
                `id` INT NOT NULL AUTO_INCREMENT,
                `entityA` INT NULL,
                `entityAType` VARCHAR(45) NULL,
                `entityB` INT NULL,
                `entityBType` VARCHAR(45) NULL,
                `relationship` VARCHAR(45) NULL,
                `createdOn` DATETIME NULL,
                `createdBy` INT NULL,
                `meta` TEXT NULL,
                PRIMARY KEY (`id`),
                INDEX `entityA` (`entityA` ASC, `entityAType` ASC, `relationship` ASC),
                INDEX `entityB` (`entityB` ASC, `entityBType` ASC, `relationship` ASC)
            ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci
        ');
    }

    /**
     * Fix the entityA column typo if it exists
     */
    private function fixEntityAColumnTypo(string $tableName): void
    {
        try {
            if ($this->columnExistsForMigration($tableName, 'enitityA')) {
                $this->connection->statement(
                    "ALTER TABLE `{$tableName}` CHANGE COLUMN `enitityA` `entityA` INT NULL"
                );
            }
        } catch (\Exception $e) {
            Log::error("Migration 30410: Failed to fix column typo in {$tableName}: ".$e->getMessage());
        }
    }

    /**
     * Ensure the entityA index exists with correct columns
     */
    private function ensureEntityAIndex(string $tableName): void
    {
        try {
            // Drop the old index if it exists (it may reference the wrong column)
            if ($this->indexExistsForMigration($tableName, 'entityA')) {
                $this->connection->statement("ALTER TABLE `{$tableName}` DROP INDEX `entityA`");
            }

            // Create the index with correct columns
            $this->connection->statement(
                "ALTER TABLE `{$tableName}` ADD INDEX `entityA` (`entityA` ASC, `entityAType` ASC, `relationship` ASC)"
            );
        } catch (\Exception $e) {
            Log::error("Migration 30410: Failed to ensure entityA index on {$tableName}: ".$e->getMessage());
        }
    }

    public function update_sql_30411(): bool|array
    {
        $errors = [];

        $sql = [
            // Add color column to zp_canvas for notebook color support
            'ALTER TABLE `zp_canvas` ADD COLUMN `color` VARCHAR(50) DEFAULT \'ocean\' AFTER `description`;',
        ];

        foreach ($sql as $statement) {
            try {
                $this->connection->statement($statement);
            } catch (\Exception $e) {
                Log::error($statement.' Failed: '.$e->getMessage());
                Log::error($e);
                // Don't fail for duplicate column
                if (! str_contains($e->getMessage(), 'Duplicate column name')) {
                    array_push($errors, $statement.' Failed: '.$e->getMessage());
                }
            }
        }

        return count($errors) ? $errors : true;
    }

    /**
     * Migration 30412: Safety net for zp_entity_relationship table
     *
     * This migration acts as a final safety net for users who may have had issues
     * with migration 30410. It performs the same checks and fixes using the shared
     * helper methods to ensure the table is in the correct state.
     *
     * Since 30410 is now robust and idempotent, this migration will typically
     * find everything already correct and simply return true.
     *
     * @return bool Always returns true to prevent blocking subsequent migrations
     */
    public function update_sql_30412(): bool|array
    {
        $pluralTable = 'zp_entity_relationships';
        $singularTable = 'zp_entity_relationship';

        try {
            $pluralExists = $this->tableExistsForMigration($pluralTable);
            $singularExists = $this->tableExistsForMigration($singularTable);

            // Handle any remaining plural table issues
            if ($pluralExists && $singularExists) {
                $this->mergeEntityRelationshipTables($pluralTable, $singularTable);
            } elseif ($pluralExists) {
                $this->connection->statement("RENAME TABLE `{$pluralTable}` TO `{$singularTable}`");
            } elseif (! $singularExists) {
                $this->createEntityRelationshipTable();

                return true;
            }

            // Ensure column and index are correct
            $this->fixEntityAColumnTypo($singularTable);
            $this->ensureEntityAIndex($singularTable);

        } catch (\Exception $e) {
            Log::error('Migration 30412: '.$e->getMessage());
        }

        return true;
    }

    /**
     * Migration 30413: Final fix for zp_entity_relationship table
     *
     * This migration ensures all users get the entity_relationship table fix,
     * including those whose DB version was already recorded as 30412+ due to
     * previous failed or partial migrations.
     *
     * Since all the helper methods are idempotent, this will simply verify
     * the table is correct (doing nothing if already fixed) or apply the fix
     * if still needed.
     *
     * @return bool Always returns true to prevent blocking subsequent migrations
     */
    public function update_sql_30413(): bool|array
    {
        $pluralTable = 'zp_entity_relationships';
        $singularTable = 'zp_entity_relationship';

        try {
            $pluralExists = $this->tableExistsForMigration($pluralTable);
            $singularExists = $this->tableExistsForMigration($singularTable);

            // Handle any remaining plural table issues
            if ($pluralExists && $singularExists) {
                $this->mergeEntityRelationshipTables($pluralTable, $singularTable);
            } elseif ($pluralExists) {
                $this->connection->statement("RENAME TABLE `{$pluralTable}` TO `{$singularTable}`");
            } elseif (! $singularExists) {
                $this->createEntityRelationshipTable();

                return true;
            }

            // Ensure column and index are correct
            $this->fixEntityAColumnTypo($singularTable);
            $this->ensureEntityAIndex($singularTable);

        } catch (\Exception $e) {
            Log::error('Migration 30413: '.$e->getMessage());
        }

        return true;
    }

    /**
     * Add performance indexes for frequently-queried columns.
     *
     * - zp_tickets.dependingTicketId: Used in every subtask query (was full table scan)
     * - zp_tickethistory.ticketId: Used in ticket history lookups
     * - zp_read (userId, module, moduleId): Table had zero indexes
     * - zp_relationuserproject (userId, projectId): Used in auth checks
     * - zp_comment (moduleId, module, date): Used in "latest comment" queries
     */
    public function update_sql_30500(): bool|array
    {
        $indexes = [
            ['table' => 'zp_tickets', 'columns' => ['dependingTicketId'], 'name' => 'idx_tickets_dependingTicketId'],
            ['table' => 'zp_tickethistory', 'columns' => ['ticketId'], 'name' => 'idx_tickethistory_ticketId'],
            ['table' => 'zp_read', 'columns' => ['userId', 'module', 'moduleId'], 'name' => 'idx_read_userId_module_moduleId'],
            ['table' => 'zp_relationuserproject', 'columns' => ['userId', 'projectId'], 'name' => 'idx_relationuserproject_userId_projectId'],
            ['table' => 'zp_comment', 'columns' => ['moduleId', 'module', 'date'], 'name' => 'idx_comment_moduleId_module_date'],
        ];

        foreach ($indexes as $index) {
            try {
                if (! Schema::hasTable($index['table'])) {
                    continue;
                }

                // Check if index already exists before adding
                $existingIndexes = collect(
                    $this->connection->select("SHOW INDEX FROM `{$index['table']}`")
                )->pluck('Key_name')->unique()->toArray();

                if (! in_array($index['name'], $existingIndexes)) {
                    Schema::table($index['table'], function (Blueprint $table) use ($index) {
                        $table->index($index['columns'], $index['name']);
                    });
                }
            } catch (\Exception $e) {
                Log::error("Migration 30500: Failed to add index {$index['name']} on {$index['table']}: ".$e->getMessage());
            }
        }

        return true;
    }

    /**
     * Migration 30501: Ensure zp_canvas.color column exists
     *
     * Migration 30411 added this column but could fail silently on MySQL servers
     * with ANSI_QUOTES sql_mode due to DEFAULT "ocean" using double quotes
     * (interpreted as identifier, not string literal). The SQL was fixed in #3284
     * but users who already ran the broken migration have the DB version advanced
     * past 30411 without the column actually existing.
     *
     * @return bool|array Returns true on success, array of errors on failure
     */
    public function update_sql_30501(): bool|array
    {
        try {
            if (Schema::hasTable('zp_canvas') && ! Schema::hasColumn('zp_canvas', 'color')) {
                Schema::table('zp_canvas', function (Blueprint $table) {
                    $table->string('color', 50)->nullable()->default('ocean')->after('description');
                });
            }
        } catch (\Exception $e) {
            Log::error('Migration 30501: '.$e->getMessage());

            return ['Migration 30501 failed: '.$e->getMessage()];
        }

        return true;
    }

    /**
     * Migration 30502: Create the WorkStructure tables (structures, elements,
     * relationships, mappings) for the meta-model that orchestrates entities
     * across domains. Mirrors SchemaBuilder::createWorkStructureTables().
     *
     * @return bool|array Returns true on success, array of errors on failure
     */
    public function update_sql_30502(): bool|array
    {
        try {
            if (! Schema::hasTable('zp_work_structures')) {
                Schema::create('zp_work_structures', function (Blueprint $table) {
                    $table->id();
                    $table->string('title', 255);
                    $table->text('description')->nullable();
                    $table->string('type', 50)->default('custom');
                    $table->integer('created_by')->nullable();
                    $table->json('meta')->nullable();
                    $table->dateTime('created_at')->nullable();
                    $table->dateTime('modified_at')->nullable();

                    $table->unique(['title'], 'idx_work_structures_title');
                    $table->index(['type'], 'idx_work_structures_type');
                });
            }

            if (! Schema::hasTable('zp_work_structure_elements')) {
                Schema::create('zp_work_structure_elements', function (Blueprint $table) {
                    $table->id();
                    $table->unsignedBigInteger('structure_id');
                    $table->string('type_key', 50);
                    $table->string('label', 100);
                    $table->text('description')->nullable();
                    $table->string('domain_reference', 255)->nullable();
                    $table->integer('sort_order')->default(0);
                    $table->json('meta')->nullable();
                    $table->dateTime('created_at')->nullable();

                    $table->index(['structure_id'], 'idx_wse_structure_id');
                    $table->unique(['structure_id', 'type_key'], 'idx_wse_structure_type_key');
                });
            }

            if (! Schema::hasTable('zp_work_structure_relationships')) {
                Schema::create('zp_work_structure_relationships', function (Blueprint $table) {
                    $table->id();
                    $table->unsignedBigInteger('structure_id');
                    $table->unsignedBigInteger('from_element_id');
                    $table->unsignedBigInteger('to_element_id');
                    $table->string('relationship_type', 50);
                    $table->text('description')->nullable();
                    $table->json('meta')->nullable();

                    $table->index(['structure_id'], 'idx_wsr_structure_id');
                });
            }

            if (! Schema::hasTable('zp_work_structure_mappings')) {
                Schema::create('zp_work_structure_mappings', function (Blueprint $table) {
                    $table->id();
                    $table->unsignedBigInteger('source_structure_id');
                    $table->unsignedBigInteger('source_element_id');
                    $table->unsignedBigInteger('target_structure_id');
                    $table->unsignedBigInteger('target_element_id');
                    $table->string('mapping_type', 50)->default('generates');
                    $table->json('meta')->nullable();

                    $table->index(['source_structure_id', 'target_structure_id'], 'idx_wsm_source_target');
                    // Enforce the same idempotency key StructureRegistry::registerMappings()
                    // checks in application code, so a race can't insert a duplicate mapping
                    // for the same source element → target structure.
                    $table->unique(['source_structure_id', 'source_element_id', 'target_structure_id'], 'idx_wsm_unique_mapping');
                });
            }
        } catch (\Exception $e) {
            Log::error('Migration 30502: '.$e->getMessage());

            return ['Migration 30502 failed: '.$e->getMessage()];
        }

        return true;
    }

    /**
     * Push notification fields on zp_access_tokens — refactor of the
     * original (never-fired-in-production) zp_device_tokens table from
     * the earlier #3401 design. Per discussion: lifecycle is naturally
     * tied to the user's login session, so we piggyback the bearer-
     * token row instead of maintaining a parallel table + prune cron.
     * Logout invalidates the row → push registration dies with it.
     *
     * Columns added to zp_access_tokens:
     *   - push_token            VARCHAR(255) NULL — opaque token (Expo
     *                                              or FCM, see provider)
     *   - push_platform         VARCHAR(16)  NULL — 'ios' or 'android'
     *   - push_provider         VARCHAR(8)   NULL — 'expo' or 'fcm'
     *   - push_token_updated_at TIMESTAMP    NULL — refreshed each
     *                                              registerPushToken call
     *   - push_invalidated_at   TIMESTAMP    NULL — set by mobile
     *                                              unregister OR provider
     *                                              DeviceNotRegistered
     *
     * The zp_device_tokens table from #3401's update_sql_30503 is no
     * longer used. Installs that ran 30503 will have an empty
     * zp_device_tokens table sitting unused — safe to drop in a
     * future cleanup PR; not dropped here to keep this migration
     * additive-only.
     */
    public function update_sql_30504(): bool|array
    {
        try {
            // Self-heal a missing table rather than dying on it (#3706). zp_access_tokens is
            // created by update_sql_30400, but that migration wrapped its statements in a
            // swallow-everything try/catch and still returned success — so an install whose
            // CREATE TABLE failed recorded 3.4.0 as applied with no table to show for it, and
            // every later upgrade died here on "1146 Table 'zp_access_tokens' doesn't exist"
            // with no way forward. Recreating it is safe: the table only holds API tokens, and
            // an install that never had one has none to lose.
            if (! Schema::hasTable('zp_access_tokens')) {
                Log::warning('Migration 30504: zp_access_tokens missing, recreating it before adding push columns.');
                app()->make(SchemaBuilder::class)->createAccessTokensTable();
            }

            Schema::table('zp_access_tokens', function (Blueprint $table) {
                if (! Schema::hasColumn('zp_access_tokens', 'push_token')) {
                    $table->string('push_token', 255)->nullable()->after('expires_at');
                }
                if (! Schema::hasColumn('zp_access_tokens', 'push_platform')) {
                    $table->string('push_platform', 16)->nullable()->after('push_token');
                }
                if (! Schema::hasColumn('zp_access_tokens', 'push_provider')) {
                    $table->string('push_provider', 8)->nullable()->after('push_platform');
                }
                if (! Schema::hasColumn('zp_access_tokens', 'push_token_updated_at')) {
                    $table->timestamp('push_token_updated_at')->nullable()->after('push_provider');
                }
                if (! Schema::hasColumn('zp_access_tokens', 'push_invalidated_at')) {
                    $table->timestamp('push_invalidated_at')->nullable()->after('push_token_updated_at');
                }
            });

            // Index for "active push tokens for user" — the dominant
            // access pattern when dispatching push. Skipped if it
            // already exists from a re-run.
            $existingIndexes = collect(\Illuminate\Support\Facades\DB::select('SHOW INDEX FROM zp_access_tokens'))
                ->pluck('Key_name')
                ->toArray();
            if (! in_array('idx_access_tokens_tokenable_push', $existingIndexes, true)) {
                Schema::table('zp_access_tokens', function (Blueprint $table) {
                    $table->index(
                        ['tokenable_id', 'push_invalidated_at'],
                        'idx_access_tokens_tokenable_push'
                    );
                });
            }
        } catch (\Exception $e) {
            Log::error('Migration 30504: '.$e->getMessage());

            return ['Migration 30504 failed: '.$e->getMessage()];
        }

        return true;
    }

    /**
     * Migration 30518 — the single native-permission-engine migration for existing installs.
     *
     * Creates the three engine tables (zp_roles, zp_permissions, zp_role_permissions — mirroring
     * {@see \Leantime\Domain\Install\Services\SchemaBuilder}, which covers fresh installs), then
     * syncs the discovered `domain.action` vocabulary and seeds the six built-in roles with their
     * default grants.
     *
     * This consolidates what was originally rolled out as 30505 (tables + first seed) plus the
     * per-domain re-seeds 30506–30517 — each an idempotent `flush → sync → seed` that picked up
     * one more domain's permission provider. syncDiscoveredPermissions() discovers ALL providers
     * and seedBuiltInRoles() applies the FULL matrix, so one seed reproduces the entire sequence.
     * Pre-release: no installed DB ran the intermediate versions, so collapsing them is safe and
     * keeps the migration history honest.
     *
     * Idempotent + additive: re-running never drops an admin's customized zp_role_permissions
     * rows. The registry cache is flushed first so a stale discovered-provider list can't cause a
     * partial seed.
     *
     * @return bool|array True on success, array of error strings on failure.
     */
    public function update_sql_30518(): bool|array
    {
        try {
            // The legacy zp_roles rights table was dropped at update_sql_30002. If a stale copy
            // survives on a very old install it lacks the 'level' column — replace it.
            if (Schema::hasTable('zp_roles') && ! Schema::hasColumn('zp_roles', 'level')) {
                Schema::drop('zp_roles');
            }

            if (! Schema::hasTable('zp_roles')) {
                Schema::create('zp_roles', function (Blueprint $table) {
                    $table->id();
                    $table->string('name', 50);
                    $table->string('displayName', 100)->nullable();
                    $table->integer('level');
                    $table->tinyInteger('isSystem')->default(0);
                    $table->text('description')->nullable();
                    $table->dateTime('createdOn')->nullable();
                    $table->dateTime('modified')->nullable();

                    $table->unique(['name'], 'idx_roles_name');
                    $table->index(['level'], 'idx_roles_level');
                });
            }

            if (! Schema::hasTable('zp_permissions')) {
                Schema::create('zp_permissions', function (Blueprint $table) {
                    $table->id();
                    $table->string('permissionKey', 150);
                    $table->string('domain', 60);
                    $table->string('action', 100);
                    $table->string('label', 191)->nullable();
                    $table->tinyInteger('isProjectScoped')->default(1);
                    $table->dateTime('createdOn')->nullable();
                    $table->dateTime('modified')->nullable();

                    $table->unique(['permissionKey'], 'idx_permissions_key');
                    $table->index(['domain'], 'idx_permissions_domain');
                });
            }

            if (! Schema::hasTable('zp_role_permissions')) {
                Schema::create('zp_role_permissions', function (Blueprint $table) {
                    $table->id();
                    $table->unsignedBigInteger('roleId');
                    $table->unsignedBigInteger('permissionId');

                    $table->unique(['roleId', 'permissionId'], 'idx_role_permissions_unique');
                    $table->index(['roleId'], 'idx_role_permissions_roleId');
                    $table->index(['permissionId'], 'idx_role_permissions_permissionId');
                });
            }

            // Populate the vocabulary, then grant the built-in roles their defaults. Flush the
            // discovered-provider cache first so every domain's permission provider is rediscovered.
            app(\Leantime\Core\Auth\Permissions\PermissionRegistry::class)->flush();

            $seeder = app(\Leantime\Core\Auth\Permissions\PermissionSeeder::class);
            $seeder->syncDiscoveredPermissions();
            $seeder->seedBuiltInRoles();
        } catch (\Exception $e) {
            Log::error('Migration 30518: '.$e->getMessage());

            return ['Migration 30518 failed: '.$e->getMessage()];
        }

        return true;
    }

    /**
     * Migration 30519 — grant the new `plugins.manage` capability to existing installs.
     *
     * The plugin-management surface (marketplace/folder install, enable, disable, remove,
     * discover) is now gated by `plugins.manage`. Fresh installs pick this up through the
     * built-in seed, but installs already past 30518 have no row for the new key — which would
     * deny everyone, including admins. Sync the vocabulary and grant the key to admin + owner
     * only. This is a targeted grant, NOT a full reseed, so any custom role edits/revocations
     * an operator has made are preserved.
     */
    public function update_sql_30519(): bool|array
    {
        try {
            app(\Leantime\Core\Auth\Permissions\PermissionRegistry::class)->flush();

            $seeder = app(\Leantime\Core\Auth\Permissions\PermissionSeeder::class);
            $seeder->syncDiscoveredPermissions();

            $repo = app(\Leantime\Core\Auth\Permissions\PermissionRepository::class);

            foreach (['admin', 'owner'] as $roleName) {
                $role = $repo->getRoleByName($roleName);

                if ($role !== null) {
                    $repo->grant((int) $role['id'], \Leantime\Domain\Plugins\Permissions\PluginsPermissions::MANAGE);
                }
            }

            app(\Leantime\Core\Auth\Permissions\PermissionService::class)->flushCache();
        } catch (\Exception $e) {
            Log::error('Migration 30519: '.$e->getMessage());

            return ['Migration 30519 failed: '.$e->getMessage()];
        }

        return true;
    }

    /**
     * Migration 30520 — grant the new api.manage and connector.manage capabilities to existing
     * installs. The API-key management and Connector integration surfaces are now permission-gated;
     * fresh installs pick these up through the built-in seed, but installs already on the permission
     * engine have no row for the new keys — which would deny everyone, including admins. Sync the
     * vocabulary and grant both keys to admin + owner only (targeted grant, not a full reseed, so
     * any custom role edits/revocations are preserved).
     */
    public function update_sql_30520(): bool|array
    {
        try {
            app(\Leantime\Core\Auth\Permissions\PermissionRegistry::class)->flush();

            $seeder = app(\Leantime\Core\Auth\Permissions\PermissionSeeder::class);
            $seeder->syncDiscoveredPermissions();

            $repo = app(\Leantime\Core\Auth\Permissions\PermissionRepository::class);
            $keys = [
                \Leantime\Domain\Api\Permissions\ApiPermissions::MANAGE,
                \Leantime\Domain\Connector\Permissions\ConnectorPermissions::MANAGE,
            ];

            foreach (['admin', 'owner'] as $roleName) {
                $role = $repo->getRoleByName($roleName);

                if ($role !== null) {
                    foreach ($keys as $key) {
                        $repo->grant((int) $role['id'], $key);
                    }
                }
            }

            app(\Leantime\Core\Auth\Permissions\PermissionService::class)->flushCache();
        } catch (\Exception $e) {
            Log::error('Migration 30520: '.$e->getMessage());

            return ['Migration 30520 failed: '.$e->getMessage()];
        }

        return true;
    }

    /**
     * Migration 30521 — reporting groundwork (#reporting-screens):
     *   - zp_tickets.outcomeImpact TEXT NULL: retrospective outcome & impact narrative on
     *     milestones ("what did completing this produce"), captured inline on the report
     *     screens and rolled up into plan/strategy board reports. Distinct from `description`,
     *     which is forward-looking.
     *   - zp_goal_history: append-only record of goal currentValue changes. Goal values were
     *     previously overwritten in place, making KPI trend reporting impossible; rows are
     *     written on every value change plus a daily snapshot, so trends become chartable
     *     once history accumulates.
     */
    public function update_sql_30521(): bool|array
    {
        try {
            if (Schema::hasTable('zp_tickets') && ! Schema::hasColumn('zp_tickets', 'outcomeImpact')) {
                Schema::table('zp_tickets', function (Blueprint $table) {
                    $table->text('outcomeImpact')->nullable()->after('acceptanceCriteria');
                });
            }

            if (! Schema::hasTable('zp_goal_history')) {
                Schema::create('zp_goal_history', function (Blueprint $table) {
                    $table->increments('id');
                    $table->integer('itemId');
                    $table->double('value')->nullable();
                    $table->integer('userId')->nullable();
                    $table->dateTime('dateRecorded')->nullable();

                    $table->index(['itemId', 'dateRecorded'], 'idx_goal_history_item_date');
                });
            }
        } catch (\Exception $e) {
            Log::error('Migration 30521: '.$e->getMessage());

            return ['Migration 30521 failed: '.$e->getMessage()];
        }

        return true;
    }

    /**
     * Migration 30522: adds two authored-meaning fields to canvas items.
     *
     *   why_this_matters — the human change (Outcome and Impact items).
     *   starting_picture — the world today, before the work (Impact only).
     *
     * Both nullable, both additive. `conclusion` is untouched — going forward
     * it narrows to "as measured by" methodology only. The report's Impact
     * Journey page (Page 4) reads `why_this_matters` as the meaning lead
     * where present, falling back to today's rendering when absent.
     */
    public function update_sql_30522(): bool|array
    {
        try {
            if (Schema::hasTable('zp_canvas_items')) {
                if (! Schema::hasColumn('zp_canvas_items', 'why_this_matters')) {
                    Schema::table('zp_canvas_items', function (Blueprint $table) {
                        $table->text('why_this_matters')->nullable()->after('conclusion');
                    });
                }
                if (! Schema::hasColumn('zp_canvas_items', 'starting_picture')) {
                    Schema::table('zp_canvas_items', function (Blueprint $table) {
                        $table->text('starting_picture')->nullable()->after('why_this_matters');
                    });
                }
            }
        } catch (\Exception $e) {
            Log::error('Migration 30522: '.$e->getMessage());

            return ['Migration 30522 failed: '.$e->getMessage()];
        }

        return true;
    }

    /**
     * update_sql_30523 — database update for v3.5.23.
     *
     * Adds user-level capacity attributes so downstream resource-planning
     * surfaces (starting with PgmPro's Resource Allocation tab) can
     * distinguish an FTE's target from a PT's ceiling, a contractor's
     * billable cap, and a volunteer's best-effort throughput.
     *
     * Both columns are nullable with no default and no backfill —
     * per product decision: teach users to configure this explicitly
     * rather than assume everyone is 40h/FTE. Downstream code treats
     * NULL as "not configured" and prompts admins to set it before
     * capacity warnings can fire.
     */
    public function update_sql_30523(): bool|array
    {
        try {
            if (! Schema::hasTable('zp_user')) {
                return true;
            }

            if (! Schema::hasColumn('zp_user', 'weekly_hours')) {
                Schema::table('zp_user', function (Blueprint $table) {
                    $table->integer('weekly_hours')->nullable()->after('hours');
                });
            }
            if (! Schema::hasColumn('zp_user', 'employment_type')) {
                Schema::table('zp_user', function (Blueprint $table) {
                    $table->string('employment_type', 20)->nullable()->after('weekly_hours');
                });
            }
        } catch (\Exception $e) {
            Log::error('Migration 30523: '.$e->getMessage());

            return ['Migration 30523 failed: '.$e->getMessage()];
        }

        return true;
    }

    /**
     * update_sql_30524 — database update for v3.5.24.
     *
     * Backfills the legacy single goal→milestone link (the varchar
     * `zp_canvas_items.milestoneId` column, `box='goal'`) into many-to-many
     * edges on the core `zp_entity_relationship` graph, so a goal can be
     * tracked by any number of milestones. Each edge:
     *   entityA = goal canvas item (GoalItem), entityB = milestone (Ticket),
     *   relationship = 'tracked_by'.
     *
     * The `milestoneId` column is intentionally KEPT here — readers are cut
     * over incrementally and a later migration drops it once nothing reads it.
     *
     * Written with the query builder (not raw REGEXP/CAST) so it is portable
     * across MySQL/Postgres/MSSQL, and idempotent: junk values (empty, '0',
     * non-numeric, deleted-milestone) are skipped and already-migrated pairs
     * are not duplicated on re-run.
     */
    public function update_sql_30524(): bool|array
    {
        try {
            // Guard on the installer's own connection (not the global Schema
            // facade, which checks the default connection) so the existence
            // check matches the connection the migration queries run against
            // (may be a temp/target install connection).
            // DatabaseManager always resolves a concrete Connection here; the
            // property is typed to the interface, which doesn't declare the
            // schema-builder accessor, so narrow it for static analysis.
            /** @var \Illuminate\Database\Connection $connection */
            $connection = $this->connection;
            $schema = $connection->getSchemaBuilder();
            if (! $schema->hasTable('zp_canvas_items')
                || ! $schema->hasTable('zp_canvas')
                || ! $schema->hasTable('zp_entity_relationship')
                || ! $schema->hasTable('zp_tickets')
                || ! $schema->hasColumn('zp_canvas_items', 'milestoneId')) {
                // Surface the skip in the update log — a partial install
                // silently no-oping would be invisible otherwise.
                Log::info('Migration 30524 skipped: required tables/columns missing (partial install?)');

                return true;
            }

            // UTC — DB datetimes are stored in UTC; date() would use the server
            // timezone and write a skewed createdOn.
            $now = gmdate('Y-m-d H:i:s');

            // Chunk the goal rows so a very large zp_canvas_items never loads
            // into memory at once. Each chunk resolves its own live-milestone
            // and existing-edge sets, scoped to the chunk's ids (no full-table
            // scan), then batch-inserts.
            $this->connection->table('zp_canvas_items')
                ->where('box', 'goal')
                ->whereNotNull('milestoneId')
                ->where('milestoneId', '<>', '')
                ->where('milestoneId', '<>', '0')
                ->orderBy('id')
                ->chunkById(500, function ($goals) use ($now): void {
                    // Numeric-only (goal, milestone) pairs. milestoneId is a
                    // varchar, so trim before the digit check.
                    $pairs = [];
                    $milestoneIds = [];
                    $canvasIds = [];
                    foreach ($goals as $g) {
                        $raw = trim((string) $g->milestoneId);
                        if (! ctype_digit($raw)) {
                            continue;
                        }
                        $mid = (int) $raw;
                        if ($mid <= 0) {
                            continue;
                        }
                        $pairs[] = ['goalId' => (int) $g->id, 'milestoneId' => $mid, 'author' => $g->author, 'canvasId' => (int) $g->canvasId];
                        $milestoneIds[$mid] = true;
                        $canvasIds[(int) $g->canvasId] = true;
                    }

                    if ($pairs === []) {
                        return;
                    }

                    $goalIds = array_values(array_unique(array_map(static fn ($p) => $p['goalId'], $pairs)));

                    // Drop edges to deleted milestones + dedup existing edges,
                    // both scoped to this chunk's ids — O(1) lookups, no N+1.
                    // The milestone lookup keeps projectId: links are
                    // same-project only (product rule), so a legacy
                    // cross-project row must NOT be promoted to an edge.
                    $liveTickets = [];
                    foreach (
                        $this->connection->table('zp_tickets')->whereIn('id', array_keys($milestoneIds))->where('type', 'milestone')->where('status', '<>', -1)->get(['id', 'projectId']) as $t
                    ) {
                        $liveTickets[(int) $t->id] = (int) $t->projectId;
                    }

                    // Goal projects, resolved via each goal's canvas (chunk-scoped).
                    $projectByCanvas = [];
                    foreach (
                        $this->connection->table('zp_canvas')->whereIn('id', array_keys($canvasIds))->get(['id', 'projectId']) as $c
                    ) {
                        $projectByCanvas[(int) $c->id] = (int) $c->projectId;
                    }

                    $existingEdges = [];
                    foreach (
                        $this->connection->table('zp_entity_relationship')
                            ->where('relationship', EntityRelationshipEnum::TrackedBy->value)
                            ->where('entityAType', 'GoalItem')
                            ->where('entityBType', 'Ticket')
                            ->whereIn('entityA', $goalIds)
                            ->select('entityA', 'entityB')
                            ->get() as $e
                    ) {
                        $existingEdges[sprintf('%d:%d', (int) $e->entityA, (int) $e->entityB)] = true;
                    }

                    $rows = [];
                    foreach ($pairs as $p) {
                        if (! isset($liveTickets[$p['milestoneId']])) {
                            continue;
                        }
                        // Same-project only: skip legacy rows pointing at a
                        // milestone in a different project than the goal's.
                        if (! isset($projectByCanvas[$p['canvasId']])
                            || $liveTickets[$p['milestoneId']] !== $projectByCanvas[$p['canvasId']]) {
                            continue;
                        }
                        if (isset($existingEdges[$p['goalId'].':'.$p['milestoneId']])) {
                            continue;
                        }
                        // Unknown author stays NULL ("unknown"), not 0 — 0 would
                        // read as a real user id in downstream joins/filters.
                        $author = (int) ($p['author'] ?? 0);
                        $rows[] = [
                            'entityA' => $p['goalId'],
                            'entityAType' => 'GoalItem',
                            'entityB' => $p['milestoneId'],
                            'entityBType' => 'Ticket',
                            'relationship' => EntityRelationshipEnum::TrackedBy->value,
                            'createdOn' => $now,
                            'createdBy' => $author > 0 ? $author : null,
                            'meta' => json_encode(['source' => 'milestoneId_migration']),
                        ];
                    }

                    foreach (array_chunk($rows, 200) as $insertChunk) {
                        $this->connection->table('zp_entity_relationship')->insert($insertChunk);
                    }
                });
        } catch (\Exception $e) {
            Log::error('Migration 30524: '.$e->getMessage());

            return ['Migration 30524 failed: '.$e->getMessage()];
        }

        return true;
    }

    /**
     * update_sql_30525 — database update for v3.5.25.
     *
     * Top-up backfill for the goal↔milestone edge migration. `update_sql_30524`
     * ran when the edge model shipped, but goal↔milestone assignments made
     * after that point and before dual-write went live were written to the
     * legacy `milestoneId` column only. Re-running the (idempotent) 30524
     * backfill captures those stragglers as `tracked_by` edges; goals already
     * migrated are skipped.
     */
    public function update_sql_30525(): bool|array
    {
        $result = $this->update_sql_30524();

        // Re-label a delegated failure so upgrade logs/output point at the step
        // that actually ran (30525), not the 30524 delegate.
        if (is_array($result)) {
            return ['Migration 30525 failed (delegated to 30524): '.implode('; ', array_map('strval', $result))];
        }

        return $result;
    }

    /**
     * update_sql_30526 — database update for v3.5.26.
     *
     * Hygiene pass over the goal↔milestone `tracked_by` edges:
     *  1. Removes CROSS-PROJECT edges — links are same-project only (product
     *     rule), but the original 30524/30525 backfill promoted legacy
     *     cross-project `milestoneId` rows into edges before the guard existed.
     *  2. Removes ORPHANED edges — a milestone deleted through the generic
     *     ticket-delete path (which historically skipped the goal-detach
     *     cascade) or a goal removed out-of-band leaves edges pointing at
     *     rows that no longer exist.
     *
     * Query-builder only (portable) and naturally idempotent: a clean graph
     * yields zero deletions.
     */
    public function update_sql_30526(): bool|array
    {
        try {
            /** @var \Illuminate\Database\Connection $connection */
            $connection = $this->connection;
            $schema = $connection->getSchemaBuilder();
            if (! $schema->hasTable('zp_entity_relationship')
                || ! $schema->hasTable('zp_canvas_items')
                || ! $schema->hasTable('zp_canvas')
                || ! $schema->hasTable('zp_tickets')) {
                // Surface the skip in the update log — a partial install
                // silently no-oping would be invisible otherwise.
                Log::info('Migration 30526 skipped: required tables missing (partial install?)');

                return true;
            }

            // Cross-project edges: goal's canvas project != milestone's project.
            $crossProject = $this->connection->table('zp_entity_relationship as er')
                ->join('zp_canvas_items as ci', 'er.entityA', '=', 'ci.id')
                ->join('zp_canvas as cb', 'ci.canvasId', '=', 'cb.id')
                ->join('zp_tickets as t', 'er.entityB', '=', 't.id')
                ->where('er.relationship', EntityRelationshipEnum::TrackedBy->value)
                ->where('er.entityAType', 'GoalItem')
                ->where('er.entityBType', 'Ticket')
                ->whereColumn('t.projectId', '<>', 'cb.projectId')
                ->pluck('er.id')
                ->all();

            // Orphans: entityA no longer a goal item, or entityB no longer a
            // live milestone ticket.
            $orphaned = $this->connection->table('zp_entity_relationship as er')
                ->leftJoin('zp_canvas_items as ci', function ($join): void {
                    $join->on('er.entityA', '=', 'ci.id')->where('ci.box', '=', 'goal');
                })
                ->leftJoin('zp_tickets as t', function ($join): void {
                    // "Live" = milestone-type AND not soft-deleted — matches
                    // the addGoalMilestoneLink chokepoint's definition, so an
                    // edge to a deleted milestone counts as orphaned.
                    $join->on('er.entityB', '=', 't.id')
                        ->where('t.type', '=', 'milestone')
                        ->where('t.status', '<>', -1);
                })
                ->where('er.relationship', EntityRelationshipEnum::TrackedBy->value)
                ->where('er.entityAType', 'GoalItem')
                ->where('er.entityBType', 'Ticket')
                ->where(function ($q): void {
                    $q->whereNull('ci.id')->orWhereNull('t.id');
                })
                ->pluck('er.id')
                ->all();

            $ids = array_values(array_unique(array_map('intval', array_merge($crossProject, $orphaned))));
            foreach (array_chunk($ids, 500) as $chunk) {
                $this->connection->table('zp_entity_relationship')->whereIn('id', $chunk)->delete();
            }
        } catch (\Exception $e) {
            Log::error('Migration 30526: '.$e->getMessage());

            return ['Migration 30526 failed: '.$e->getMessage()];
        }

        return true;
    }

    /**
     * update_sql_30527 — BOM (bill-of-materials) module tables + permission grants.
     *
     * Creates the zp_bom / zp_bom_item / zp_bom_column / zp_bom_source tables and
     * grants the `bom.*` capability vocabulary to the built-in roles (admin/owner get
     * everything; editor/manager get the standard project-scoped verbs via the central
     * role matrix on fresh installs, so here we only backfill admin/owner explicitly,
     * mirroring 30519/30520).
     */
    public function update_sql_30527(): bool|array
    {
        try {
            if (! Schema::hasTable('zp_bom')) {
                Schema::create('zp_bom', function (Blueprint $table) {
                    $table->id();
                    $table->integer('projectId')->nullable();
                    $table->string('bomNo', 100)->nullable();
                    $table->string('productName', 255)->nullable();
                    $table->string('specification', 255)->nullable();
                    $table->string('drawingNo', 100)->nullable();
                    $table->string('version', 50)->nullable();
                    $table->string('status', 20)->nullable()->default('0');
                    $table->text('remark')->nullable();
                    $table->dateTime('createdOn')->nullable();
                    $table->dateTime('modifiedOn')->nullable();

                    $table->index(['projectId'], 'idx_bom_projectId');
                });
            }

            if (! Schema::hasTable('zp_bom_item')) {
                Schema::create('zp_bom_item', function (Blueprint $table) {
                    $table->id();
                    $table->unsignedBigInteger('bomId');
                    $table->integer('seq')->nullable()->default(0);
                    $table->string('partNo', 100)->nullable();
                    $table->string('partName', 255)->nullable();
                    $table->string('partDrawingNo', 100)->nullable();
                    $table->string('material', 100)->nullable();
                    $table->string('spec', 255)->nullable();
                    $table->string('qtyPerUnit', 50)->nullable();
                    $table->string('unit', 50)->nullable();
                    $table->string('process', 100)->nullable();
                    $table->text('remark')->nullable();
                    $table->text('extra')->nullable();

                    $table->index(['bomId'], 'idx_bom_item_bomId');
                });
            }

            if (! Schema::hasTable('zp_bom_column')) {
                Schema::create('zp_bom_column', function (Blueprint $table) {
                    $table->id();
                    $table->unsignedBigInteger('bomId');
                    $table->string('key', 191);
                    $table->string('label', 191)->nullable();
                    $table->integer('sortOrder')->nullable()->default(0);

                    $table->index(['bomId'], 'idx_bom_column_bomId');
                    $table->unique(['bomId', 'key'], 'idx_bom_column_unique');
                });
            }

            if (! Schema::hasTable('zp_bom_source')) {
                Schema::create('zp_bom_source', function (Blueprint $table) {
                    $table->id();
                    $table->unsignedBigInteger('bomId');
                    $table->string('name', 255)->nullable();
                    $table->string('baseUrl', 1000)->nullable();
                    $table->string('tableId', 100)->nullable();
                    $table->text('token')->nullable();
                    $table->string('remark', 500)->nullable();
                    $table->dateTime('createdOn')->nullable();

                    $table->index(['bomId'], 'idx_bom_source_bomId');
                });
            }

            // Backfill the bom.* vocabulary to admin + owner. Fresh installs get the
            // editor/manager grants from the central role matrix via the seed below.
            app(\Leantime\Core\Auth\Permissions\PermissionRegistry::class)->flush();
            $seeder = app(\Leantime\Core\Auth\Permissions\PermissionSeeder::class);
            $seeder->syncDiscoveredPermissions();

            $repo = app(\Leantime\Core\Auth\Permissions\PermissionRepository::class);
            $keys = [
                \Leantime\Domain\Bom\Permissions\BomPermissions::VIEW,
                \Leantime\Domain\Bom\Permissions\BomPermissions::CREATE,
                \Leantime\Domain\Bom\Permissions\BomPermissions::EDIT,
                \Leantime\Domain\Bom\Permissions\BomPermissions::DELETE,
            ];

            foreach (['admin', 'owner'] as $roleName) {
                $role = $repo->getRoleByName($roleName);
                if ($role !== null) {
                    foreach ($keys as $key) {
                        $repo->grant((int) $role['id'], $key);
                    }
                }
            }

            app(\Leantime\Core\Auth\Permissions\PermissionService::class)->flushCache();
        } catch (\Exception $e) {
            Log::error('Migration 30527: '.$e->getMessage());

            return ['Migration 30527 failed: '.$e->getMessage()];
        }

        return true;
    }

    /**
     * update_sql_30528 — BOM 列显隐支持：zp_bom 增加 hiddenColumns（隐藏列 key 的 JSON 数组）。
     */
    public function update_sql_30528(): bool|array
    {
        try {
            if (Schema::hasTable('zp_bom') && ! Schema::hasColumn('zp_bom', 'hiddenColumns')) {
                Schema::table('zp_bom', function (Blueprint $table) {
                    $table->text('hiddenColumns')->nullable()->after('remark');
                });
            }
        } catch (\Exception $e) {
            Log::error('Migration 30528: '.$e->getMessage());

            return ['Migration 30528 failed: '.$e->getMessage()];
        }

        return true;
    }

    /**
     * update_sql_30529 — 全局主数据体系：
     *   1. zp_bom 增加 type 列（bom/process/tooling 三类主数据复用同一套表）；
     *   2. 项目引用层三张表：项目↔主数据关联、项目级追加列、项目级追加值（单向，不写回全局）。
     */
    public function update_sql_30529(): bool|array
    {
        try {
            if (Schema::hasTable('zp_bom') && ! Schema::hasColumn('zp_bom', 'type')) {
                Schema::table('zp_bom', function (Blueprint $table) {
                    $table->string('type', 20)->nullable()->default('bom')->after('id');
                });
            }

            if (! Schema::hasTable('zp_master_ref')) {
                Schema::create('zp_master_ref', function (Blueprint $table) {
                    $table->id();
                    $table->unsignedBigInteger('projectId');
                    $table->unsignedBigInteger('masterId'); // zp_bom.id（任意 type）
                    $table->dateTime('createdOn')->nullable();

                    $table->index(['projectId'], 'idx_mref_project');
                    $table->index(['masterId'], 'idx_mref_master');
                    $table->unique(['projectId', 'masterId'], 'idx_mref_unique');
                });
            }

            if (! Schema::hasTable('zp_master_ref_column')) {
                Schema::create('zp_master_ref_column', function (Blueprint $table) {
                    $table->id();
                    $table->unsignedBigInteger('refId');
                    $table->string('key', 191);
                    $table->string('label', 191)->nullable();
                    $table->integer('sortOrder')->nullable()->default(0);

                    $table->index(['refId'], 'idx_mrefcol_ref');
                    $table->unique(['refId', 'key'], 'idx_mrefcol_unique');
                });
            }

            if (! Schema::hasTable('zp_master_ref_value')) {
                Schema::create('zp_master_ref_value', function (Blueprint $table) {
                    $table->id();
                    $table->unsignedBigInteger('refId');
                    $table->unsignedBigInteger('columnId');
                    $table->unsignedBigInteger('itemId'); // zp_bom_item.id（全局明细行）
                    $table->text('value')->nullable();

                    $table->index(['refId', 'itemId'], 'idx_mrefval_refitem');
                    $table->unique(['refId', 'columnId', 'itemId'], 'idx_mrefval_unique');
                });
            }
        } catch (\Exception $e) {
            Log::error('Migration 30529: '.$e->getMessage());

            return ['Migration 30529 failed: '.$e->getMessage()];
        }

        return true;
    }
}