<?php

namespace Database\Seeders;

use BezhanSalleh\FilamentShield\Support\Utils;
use Illuminate\Database\Seeder;
use Illuminate\Support\Facades\DB;
use Spatie\Permission\PermissionRegistrar;

class ShieldSeeder extends Seeder
{
    public function run(): void
    {
        app()[PermissionRegistrar::class]->forgetCachedPermissions();

        $tenants = '[]';
        $users = '[]';
        $userTenantPivot = '[]';
        $rolesWithPermissions = <<<'JSON'
        [
            {
                "name": "Developer",
                "guard_name": "web",
                "permissions" : [
                    "View:StatsOverview",
                    "View:EggProductionChart",
                    "View:OrderTrendChart",
                    "View:RevenueExpenseChart",
                    "View:TopCustomersChart",
                    
                    "ViewAny:Chicken",
                    "View:Chicken",
                    "Create:Chicken",
                    "Update:Chicken",
                    "Delete:Chicken",
                    "Restore:Chicken",
                    "ForceDelete:Chicken",
                    "ForceDeleteAny:Chicken",
                    "RestoreAny:Chicken",
                    "Replicate:Chicken",
                    "Reorder:Chicken",

                    "ViewAny:Customer",
                    "View:Customer",
                    "Create:Customer",
                    "Update:Customer",
                    "Delete:Customer",
                    "Restore:Customer",
                    "ForceDelete:Customer",
                    "ForceDeleteAny:Customer",
                    "RestoreAny:Customer",
                    "Replicate:Customer",
                    "Reorder:Customer",

                    "ViewAny:DelayedGood",
                    "View:DelayedGood",
                    "Create:DelayedGood",
                    "Update:DelayedGood",
                    "Delete:DelayedGood",
                    "Restore:DelayedGood",
                    "ForceDelete:DelayedGood",
                    "ForceDeleteAny:DelayedGood",
                    "RestoreAny:DelayedGood",
                    "Replicate:DelayedGood",
                    "Reorder:DelayedGood",

                    "ViewAny:EggCollection",
                    "View:EggCollection",
                    "Create:EggCollection",
                    "Update:EggCollection",
                    "Delete:EggCollection",
                    "Restore:EggCollection",
                    "ForceDelete:EggCollection",
                    "ForceDeleteAny:EggCollection",
                    "RestoreAny:EggCollection",
                    "Replicate:EggCollection",
                    "Reorder:EggCollection",

                    "ViewAny:EggPrice",
                    "View:EggPrice",
                    "Create:EggPrice",
                    "Update:EggPrice",
                    "Delete:EggPrice",
                    "Restore:EggPrice",
                    "ForceDelete:EggPrice",
                    "ForceDeleteAny:EggPrice",
                    "RestoreAny:EggPrice",
                    "Replicate:EggPrice",
                    "Reorder:EggPrice",

                    "ViewAny:Expense",
                    "View:Expense",
                    "Create:Expense",
                    "Update:Expense",
                    "Delete:Expense",
                    "Restore:Expense",
                    "ForceDelete:Expense",
                    "ForceDeleteAny:Expense",
                    "RestoreAny:Expense",
                    "Replicate:Expense",
                    "Reorder:Expense",

                    "ViewAny:Feed",
                    "View:Feed",
                    "Create:Feed",
                    "Update:Feed",
                    "Delete:Feed",
                    "Restore:Feed",
                    "ForceDelete:Feed",
                    "ForceDeleteAny:Feed",
                    "RestoreAny:Feed",
                    "Replicate:Feed",
                    "Reorder:Feed",

                    "ViewAny:FeedPurchase",
                    "View:FeedPurchase",
                    "Create:FeedPurchase",
                    "Update:FeedPurchase",
                    "Delete:FeedPurchase",
                    "Restore:FeedPurchase",
                    "ForceDelete:FeedPurchase",
                    "ForceDeleteAny:FeedPurchase",
                    "RestoreAny:FeedPurchase",
                    "Replicate:FeedPurchase",
                    "Reorder:FeedPurchase",

                    "ViewAny:OrderPurchase",
                    "View:OrderPurchase",
                    "Create:OrderPurchase",
                    "Update:OrderPurchase",
                    "Delete:OrderPurchase",
                    "Restore:OrderPurchase",
                    "ForceDelete:OrderPurchase",
                    "ForceDeleteAny:OrderPurchase",
                    "RestoreAny:OrderPurchase",
                    "Replicate:OrderPurchase",
                    "Reorder:OrderPurchase",

                    "ViewAny:Order",
                    "View:Order",
                    "Create:Order",
                    "Update:Order",
                    "Delete:Order",
                    "Restore:Order",
                    "ForceDelete:Order",
                    "ForceDeleteAny:Order",
                    "RestoreAny:Order",
                    "Replicate:Order",
                    "Reorder:Order",
                    
                    "ViewAny:Unit",
                    "View:Unit",
                    "Create:Unit",
                    "Update:Unit",
                    "Delete:Unit",
                    "Restore:Unit",
                    "ForceDelete:Unit",
                    "ForceDeleteAny:Unit",
                    "RestoreAny:Unit",
                    "Replicate:Unit",
                    "Reorder:Unit",
                    
                    "ViewAny:User",
                    "View:User",
                    "Create:User",
                    "Update:User",
                    "Delete:User",
                    "Restore:User",
                    "ForceDelete:User",
                    "ForceDeleteAny:User",
                    "RestoreAny:User",
                    "Replicate:User",
                    "Reorder:User",

                    "ViewAny:Role",
                    "View:Role",
                    "Create:Role",
                    "Update:Role",
                    "Delete:Role",
                    "Restore:Role",
                    "ForceDelete:Role",
                    "ForceDeleteAny:Role",
                    "RestoreAny:Role",
                    "Replicate:Role",
                    "Reorder:Role"
                ]
            },
            {
                "name": "Pemilik",
                "guard_name": "web",
                "permissions" : []
            },
            {
                "name": "Administrator",
                "guard_name": "web",
                "permissions" : []
            }
        ]
        JSON;

        $directPermissions = '[]';

        // 1. Seed tenants first (if present)
        if (! blank($tenants) && $tenants !== '[]') {
            static::seedTenants($tenants);
        }

        // 2. Seed roles with permissions
        static::makeRolesWithPermissions($rolesWithPermissions);

        // 3. Seed direct permissions
        static::makeDirectPermissions($directPermissions);

        // 4. Seed users with their roles/permissions (if present)
        if (! blank($users) && $users !== '[]') {
            static::seedUsers($users);
        }

        // 5. Seed user-tenant pivot (if present)
        if (! blank($userTenantPivot) && $userTenantPivot !== '[]') {
            static::seedUserTenantPivot($userTenantPivot);
        }

        $this->command->info('Shield Seeding Completed.');
    }

    protected static function seedTenants(string $tenants): void
    {
        if (blank($tenantData = json_decode($tenants, true))) {
            return;
        }

        $tenantModel = '';
        if (blank($tenantModel)) {
            return;
        }

        foreach ($tenantData as $tenant) {
            $tenantModel::firstOrCreate(
                ['id' => $tenant['id']],
                $tenant
            );
        }
    }

    protected static function seedUsers(string $users): void
    {
        if (blank($userData = json_decode($users, true))) {
            return;
        }

        $userModel = 'App\Models\User';
        $tenancyEnabled = false;

        foreach ($userData as $data) {
            // Extract role/permission data before creating user
            $roles = $data['roles'] ?? [];
            $permissions = $data['permissions'] ?? [];
            $tenantRoles = $data['tenant_roles'] ?? [];
            $tenantPermissions = $data['tenant_permissions'] ?? [];
            unset($data['roles'], $data['permissions'], $data['tenant_roles'], $data['tenant_permissions']);

            $user = $userModel::firstOrCreate(
                ['email' => $data['email']],
                $data
            );

            // Handle tenancy mode - sync roles/permissions per tenant
            if ($tenancyEnabled && (! empty($tenantRoles) || ! empty($tenantPermissions))) {
                foreach ($tenantRoles as $tenantId => $roleNames) {
                    $contextId = $tenantId === '_global' ? null : $tenantId;
                    setPermissionsTeamId($contextId);
                    $user->syncRoles($roleNames);
                }

                foreach ($tenantPermissions as $tenantId => $permissionNames) {
                    $contextId = $tenantId === '_global' ? null : $tenantId;
                    setPermissionsTeamId($contextId);
                    $user->syncPermissions($permissionNames);
                }
            } else {
                // Non-tenancy mode
                if (! empty($roles)) {
                    $user->syncRoles($roles);
                }

                if (! empty($permissions)) {
                    $user->syncPermissions($permissions);
                }
            }
        }
    }

    protected static function seedUserTenantPivot(string $pivot): void
    {
        if (blank($pivotData = json_decode($pivot, true))) {
            return;
        }

        $pivotTable = '';
        if (blank($pivotTable)) {
            return;
        }

        foreach ($pivotData as $row) {
            $uniqueKeys = [];

            if (isset($row['user_id'])) {
                $uniqueKeys['user_id'] = $row['user_id'];
            }

            $tenantForeignKey = 'team_id';
            if (! blank($tenantForeignKey) && isset($row[$tenantForeignKey])) {
                $uniqueKeys[$tenantForeignKey] = $row[$tenantForeignKey];
            }

            if (! empty($uniqueKeys)) {
                DB::table($pivotTable)->updateOrInsert($uniqueKeys, $row);
            }
        }
    }

    protected static function makeRolesWithPermissions(string $rolesWithPermissions): void
    {
        if (blank($rolePlusPermissions = json_decode($rolesWithPermissions, true))) {
            return;
        }

        /** @var \Illuminate\Database\Eloquent\Model $roleModel */
        $roleModel = Utils::getRoleModel();
        /** @var \Illuminate\Database\Eloquent\Model $permissionModel */
        $permissionModel = Utils::getPermissionModel();

        $tenancyEnabled = false;
        $teamForeignKey = 'team_id';

        foreach ($rolePlusPermissions as $rolePlusPermission) {
            $tenantId = $rolePlusPermission[$teamForeignKey] ?? null;

            // Set tenant context for role creation and permission sync
            if ($tenancyEnabled) {
                setPermissionsTeamId($tenantId);
            }

            $roleData = [
                'name' => $rolePlusPermission['name'],
                'guard_name' => $rolePlusPermission['guard_name'],
            ];

            // Include tenant ID in role data (can be null for global roles)
            if ($tenancyEnabled && ! blank($teamForeignKey)) {
                $roleData[$teamForeignKey] = $tenantId;
            }

            $role = $roleModel::firstOrCreate($roleData);

            if (! blank($rolePlusPermission['permissions'])) {
                $permissionModels = collect($rolePlusPermission['permissions'])
                    ->map(fn ($permission) => $permissionModel::firstOrCreate([
                        'name' => $permission,
                        'guard_name' => $rolePlusPermission['guard_name'],
                    ]))
                    ->all();

                $role->syncPermissions($permissionModels);
            }
        }
    }

    public static function makeDirectPermissions(string $directPermissions): void
    {
        if (blank($permissions = json_decode($directPermissions, true))) {
            return;
        }

        /** @var \Illuminate\Database\Eloquent\Model $permissionModel */
        $permissionModel = Utils::getPermissionModel();

        foreach ($permissions as $permission) {
            if ($permissionModel::whereName($permission['name'])->doesntExist()) {
                $permissionModel::create([
                    'name' => $permission['name'],
                    'guard_name' => $permission['guard_name'],
                ]);
            }
        }
    }
}