#!/usr/bin/env python3
from pathlib import Path

ROOT = Path("/Applications/XAMPP/xamppfiles/htdocs/jobnixy")

controllers = {}

controllers["Users/Controllers/UserController.php"] = r'''<?php

namespace App\Modules\Users\Controllers;

use App\Http\Controllers\Controller;
use App\Models\User;
use App\Services\AuditLogger;
use Illuminate\Http\Request;

class UserController extends Controller
{
    public function index(Request $request)
    {
        $query = User::with('profile')->where('is_staff', false)->latest();

        if ($search = $request->get('q')) {
            $query->where(function ($q) use ($search) {
                $q->where('name', 'like', "%{$search}%")
                    ->orWhere('email', 'like', "%{$search}%")
                    ->orWhere('phone', 'like', "%{$search}%");
            });
        }

        if ($type = $request->get('account_type')) {
            $query->where('account_type', $type);
        }

        if ($status = $request->get('status')) {
            $query->where('status', $status);
        }

        $users = $query->paginate(20)->withQueryString();

        return view('admin.users.index', compact('users'));
    }

    public function show(User $user)
    {
        $user->load(['profile', 'kycVerifications', 'wallets', 'professional', 'agentProfile', 'trustScoreRecord']);

        return view('admin.users.show', compact('user'));
    }

    public function updateStatus(Request $request, User $user)
    {
        $data = $request->validate([
            'status' => 'required|in:active,suspended,frozen,pending',
            'reason' => 'nullable|string|max:500',
        ]);

        $old = ['status' => $user->status];
        $user->update(['status' => $data['status']]);

        AuditLogger::log('user.status_update', $user, $old, ['status' => $data['status']], $data['reason'] ?? null);

        return back()->with('success', 'User status updated.');
    }
}
'''

controllers["Identity/Controllers/KycController.php"] = r'''<?php

namespace App\Modules\Identity\Controllers;

use App\Http\Controllers\Controller;
use App\Models\KycVerification;
use App\Services\AuditLogger;
use Illuminate\Http\Request;

class KycController extends Controller
{
    public function index(Request $request)
    {
        $query = KycVerification::with('user')->latest();

        if ($status = $request->get('status')) {
            $query->where('status', $status);
        }

        $verifications = $query->paginate(20)->withQueryString();

        return view('admin.identity.index', compact('verifications'));
    }

    public function show(KycVerification $kyc)
    {
        $kyc->load(['user.profile', 'reviewer']);

        return view('admin.identity.show', compact('kyc'));
    }

    public function review(Request $request, KycVerification $kyc)
    {
        $data = $request->validate([
            'status' => 'required|in:approved,rejected,failed',
            'admin_notes' => 'nullable|string|max:1000',
            'reason' => 'nullable|string|max:500',
        ]);

        $old = $kyc->only(['status', 'admin_notes']);

        $kyc->update([
            'status' => $data['status'],
            'admin_notes' => $data['admin_notes'] ?? null,
            'reviewed_by' => auth()->id(),
            'reviewed_at' => now(),
            'failure_reason' => $data['status'] !== 'approved' ? ($data['reason'] ?? null) : null,
        ]);

        if ($data['status'] === 'approved' && $kyc->user) {
            $kyc->user->update(['kyc_level' => max((int) $kyc->user->kyc_level, (int) $kyc->level)]);
        }

        AuditLogger::log('kyc.review', $kyc, $old, $kyc->only(['status', 'admin_notes']), $data['reason'] ?? null);

        return back()->with('success', 'KYC review saved.');
    }
}
'''

controllers["Professionals/Controllers/ProfessionalController.php"] = r'''<?php

namespace App\Modules\Professionals\Controllers;

use App\Http\Controllers\Controller;
use App\Models\Professional;
use Illuminate\Http\Request;

class ProfessionalController extends Controller
{
    public function index(Request $request)
    {
        $query = Professional::with(['user', 'skills'])->latest();

        if ($search = $request->get('q')) {
            $query->where(function ($q) use ($search) {
                $q->where('display_name', 'like', "%{$search}%")
                    ->orWhere('jobnixy_id', 'like', "%{$search}%");
            });
        }

        if ($availability = $request->get('availability')) {
            $query->where('availability', $availability);
        }

        $professionals = $query->paginate(20)->withQueryString();

        return view('admin.professionals.index', compact('professionals'));
    }

    public function show(Professional $professional)
    {
        $professional->load(['user', 'skills', 'certifications', 'portfolioItems', 'agent']);

        return view('admin.professionals.show', compact('professional'));
    }

    public function update(Request $request, Professional $professional)
    {
        $data = $request->validate([
            'status' => 'required|in:active,suspended,inactive',
            'career_level' => 'nullable|in:starter,verified,professional,expert,master',
            'skill_verified' => 'nullable|boolean',
        ]);

        $professional->update([
            'status' => $data['status'],
            'career_level' => $data['career_level'] ?? $professional->career_level,
            'skill_verified' => $request->boolean('skill_verified'),
        ]);

        return back()->with('success', 'Professional updated.');
    }
}
'''

controllers["Skills/Controllers/SkillController.php"] = r'''<?php

namespace App\Modules\Skills\Controllers;

use App\Http\Controllers\Controller;
use App\Models\Skill;
use App\Models\SkillCategory;
use Illuminate\Http\Request;
use Illuminate\Support\Str;

class SkillController extends Controller
{
    public function index()
    {
        $categories = SkillCategory::with('skills')->orderBy('sort_order')->get();
        $skills = Skill::with('category')->latest()->paginate(30);

        return view('admin.skills.index', compact('categories', 'skills'));
    }

    public function storeCategory(Request $request)
    {
        $data = $request->validate([
            'name' => 'required|string|max:120',
            'parent_id' => 'nullable|exists:skill_categories,id',
        ]);

        SkillCategory::create([
            'name' => $data['name'],
            'slug' => Str::slug($data['name']),
            'parent_id' => $data['parent_id'] ?? null,
            'is_active' => true,
        ]);

        return back()->with('success', 'Category created.');
    }

    public function storeSkill(Request $request)
    {
        $data = $request->validate([
            'name' => 'required|string|max:120',
            'category_id' => 'nullable|exists:skill_categories,id',
            'default_radius_km' => 'nullable|integer|min:1|max:500',
            'is_remote_capable' => 'nullable|boolean',
        ]);

        Skill::create([
            'name' => $data['name'],
            'slug' => Str::slug($data['name']) . '-' . Str::random(4),
            'category_id' => $data['category_id'] ?? null,
            'default_radius_km' => $data['default_radius_km'] ?? 10,
            'is_remote_capable' => $request->boolean('is_remote_capable'),
            'is_active' => true,
        ]);

        return back()->with('success', 'Skill created.');
    }

    public function toggleSkill(Skill $skill)
    {
        $skill->update(['is_active' => ! $skill->is_active]);

        return back()->with('success', 'Skill status updated.');
    }
}
'''

controllers["Jobs/Controllers/JobController.php"] = r'''<?php

namespace App\Modules\Jobs\Controllers;

use App\Http\Controllers\Controller;
use App\Models\WorkJob;
use App\Services\AuditLogger;
use Illuminate\Http\Request;

class JobController extends Controller
{
    public function index(Request $request)
    {
        $query = WorkJob::with(['employer', 'skill', 'assignedProfessional', 'location'])->latest();

        if ($status = $request->get('status')) {
            $query->where('status', $status);
        }

        if ($mode = $request->get('hire_mode')) {
            $query->where('hire_mode', $mode);
        }

        if ($search = $request->get('q')) {
            $query->where(function ($q) use ($search) {
                $q->where('title', 'like', "%{$search}%")
                    ->orWhere('reference', 'like', "%{$search}%");
            });
        }

        $jobs = $query->paginate(20)->withQueryString();

        return view('admin.jobs.index', compact('jobs'));
    }

    public function show(WorkJob $job)
    {
        $job->load([
            'employer', 'skill', 'category', 'location', 'assignedProfessional.user',
            'candidates.professional', 'bids.professional', 'contract.milestones',
            'session', 'escrows', 'disputes',
        ]);

        return view('admin.jobs.show', ['job' => $job]);
    }

    public function updateStatus(Request $request, WorkJob $job)
    {
        $data = $request->validate([
            'status' => 'required|string|max:40',
            'reason' => 'nullable|string|max:500',
        ]);

        $old = ['status' => $job->status];
        $job->update(['status' => $data['status']]);
        AuditLogger::log('job.status_update', $job, $old, ['status' => $data['status']], $data['reason'] ?? null);

        return back()->with('success', 'Job status updated.');
    }
}
'''

controllers["Finance/Controllers/FinanceController.php"] = r'''<?php

namespace App\Modules\Finance\Controllers;

use App\Http\Controllers\Controller;
use App\Models\Commission;
use App\Models\EscrowAccount;
use App\Models\Payment;
use App\Models\Payout;
use App\Models\Wallet;
use App\Models\WalletTransaction;
use App\Services\AuditLogger;
use Illuminate\Http\Request;

class FinanceController extends Controller
{
    public function wallets(Request $request)
    {
        $wallets = Wallet::with('user')->latest()->paginate(20);

        return view('admin.finance.wallets', compact('wallets'));
    }

    public function walletShow(Wallet $wallet)
    {
        $wallet->load('user');
        $transactions = WalletTransaction::where('wallet_id', $wallet->id)->latest()->paginate(25);

        return view('admin.finance.wallet-show', compact('wallet', 'transactions'));
    }

    public function escrows(Request $request)
    {
        $query = EscrowAccount::with(['workJob', 'payer'])->latest();
        if ($status = $request->get('status')) {
            $query->where('status', $status);
        }
        $escrows = $query->paginate(20)->withQueryString();

        return view('admin.finance.escrows', compact('escrows'));
    }

    public function escrowShow(EscrowAccount $escrow)
    {
        $escrow->load(['workJob', 'payer', 'contract']);

        return view('admin.finance.escrow-show', compact('escrow'));
    }

    public function releaseEscrow(Request $request, EscrowAccount $escrow)
    {
        $data = $request->validate(['reason' => 'required|string|max:500']);

        if (! in_array($escrow->status, ['held', 'partially_released'], true)) {
            return back()->withErrors(['status' => 'Escrow cannot be released from current status.']);
        }

        $old = $escrow->only(['status', 'released_amount']);
        $escrow->update([
            'status' => 'released',
            'released_amount' => $escrow->amount,
            'released_at' => now(),
        ]);

        AuditLogger::log('escrow.release', $escrow, $old, $escrow->only(['status', 'released_amount']), $data['reason']);

        return back()->with('success', 'Escrow released (admin override).');
    }

    public function payments()
    {
        $payments = Payment::with('user')->latest()->paginate(25);

        return view('admin.finance.payments', compact('payments'));
    }

    public function payouts()
    {
        $payouts = Payout::with('user')->latest()->paginate(25);

        return view('admin.finance.payouts', compact('payouts'));
    }

    public function commissions()
    {
        $commissions = Commission::with('workJob')->latest()->paginate(25);

        return view('admin.finance.commissions', compact('commissions'));
    }
}
'''

controllers["Agents/Controllers/AgentController.php"] = r'''<?php

namespace App\Modules\Agents\Controllers;

use App\Http\Controllers\Controller;
use App\Models\Agent;
use Illuminate\Http\Request;

class AgentController extends Controller
{
    public function index(Request $request)
    {
        $query = Agent::with('user')->latest();
        if ($search = $request->get('q')) {
            $query->where('organization_name', 'like', "%{$search}%");
        }
        $agents = $query->paginate(20)->withQueryString();

        return view('admin.agents.index', compact('agents'));
    }

    public function show(Agent $agent)
    {
        $agent->load(['user', 'workers.professional.user']);

        return view('admin.agents.show', compact('agent'));
    }

    public function update(Request $request, Agent $agent)
    {
        $data = $request->validate([
            'status' => 'required|in:active,suspended,inactive',
            'default_commission_percent' => 'nullable|numeric|min:0|max:50',
        ]);

        $agent->update($data);

        return back()->with('success', 'Agent updated.');
    }
}
'''

controllers["Disputes/Controllers/DisputeController.php"] = r'''<?php

namespace App\Modules\Disputes\Controllers;

use App\Http\Controllers\Controller;
use App\Models\Dispute;
use App\Services\AuditLogger;
use Illuminate\Http\Request;

class DisputeController extends Controller
{
    public function index(Request $request)
    {
        $query = Dispute::with(['workJob', 'opener', 'officer'])->latest();
        if ($status = $request->get('status')) {
            $query->where('status', $status);
        }
        $disputes = $query->paginate(20)->withQueryString();

        return view('admin.disputes.index', compact('disputes'));
    }

    public function show(Dispute $dispute)
    {
        $dispute->load(['workJob.contract', 'opener', 'against', 'officer', 'evidences.uploader']);

        return view('admin.disputes.show', compact('dispute'));
    }

    public function resolve(Request $request, Dispute $dispute)
    {
        $data = $request->validate([
            'status' => 'required|in:under_review,awaiting_evidence,resolved,closed',
            'resolution' => 'nullable|in:favor_employer,favor_worker,partial,cancelled',
            'resolution_notes' => 'nullable|string|max:2000',
        ]);

        $old = $dispute->only(['status', 'resolution']);
        $dispute->update([
            'status' => $data['status'],
            'resolution' => $data['resolution'] ?? $dispute->resolution,
            'resolution_notes' => $data['resolution_notes'] ?? $dispute->resolution_notes,
            'assigned_officer_id' => auth()->id(),
            'resolved_at' => in_array($data['status'], ['resolved', 'closed'], true) ? now() : null,
        ]);

        AuditLogger::log('dispute.resolve', $dispute, $old, $dispute->only(['status', 'resolution']), $data['resolution_notes'] ?? null);

        return back()->with('success', 'Dispute updated.');
    }
}
'''

controllers["Risk/Controllers/RiskController.php"] = r'''<?php

namespace App\Modules\Risk\Controllers;

use App\Http\Controllers\Controller;
use App\Models\RiskEvent;
use App\Models\User;
use App\Services\AuditLogger;
use Illuminate\Http\Request;

class RiskController extends Controller
{
    public function index(Request $request)
    {
        $query = RiskEvent::with('user')->latest();
        if ($severity = $request->get('severity')) {
            $query->where('severity', $severity);
        }
        if ($status = $request->get('status')) {
            $query->where('status', $status);
        }
        $events = $query->paginate(20)->withQueryString();

        return view('admin.risk.index', compact('events'));
    }

    public function show(RiskEvent $risk)
    {
        $risk->load(['user', 'reviewer']);

        return view('admin.risk.show', compact('risk'));
    }

    public function review(Request $request, RiskEvent $risk)
    {
        $data = $request->validate([
            'status' => 'required|in:open,investigating,cleared,confirmed',
            'notes' => 'nullable|string|max:1000',
            'freeze_user' => 'nullable|boolean',
        ]);

        $old = $risk->only(['status']);
        $risk->update([
            'status' => $data['status'],
            'notes' => $data['notes'] ?? null,
            'reviewed_by' => auth()->id(),
            'reviewed_at' => now(),
        ]);

        if ($request->boolean('freeze_user') && $risk->user_id) {
            User::where('id', $risk->user_id)->update(['status' => 'frozen']);
            AuditLogger::log('user.freeze', $risk->user, null, ['status' => 'frozen'], $data['notes'] ?? 'Risk freeze');
        }

        AuditLogger::log('risk.review', $risk, $old, $risk->only(['status']), $data['notes'] ?? null);

        return back()->with('success', 'Risk event reviewed.');
    }
}
'''

controllers["Reviews/Controllers/ReviewController.php"] = r'''<?php

namespace App\Modules\Reviews\Controllers;

use App\Http\Controllers\Controller;
use App\Models\Review;
use Illuminate\Http\Request;

class ReviewController extends Controller
{
    public function index(Request $request)
    {
        $reviews = Review::with(['workJob', 'reviewer', 'reviewee'])->latest()->paginate(25);

        return view('admin.reviews.index', compact('reviews'));
    }

    public function toggle(Review $review)
    {
        $review->update(['is_visible' => ! $review->is_visible]);

        return back()->with('success', 'Review visibility updated.');
    }
}
'''

controllers["Staff/Controllers/StaffController.php"] = r'''<?php

namespace App\Modules\Staff\Controllers;

use App\Http\Controllers\Controller;
use App\Models\Role;
use App\Models\User;
use App\Services\AuditLogger;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Hash;

class StaffController extends Controller
{
    public function index()
    {
        $staff = User::with('roles')->where('is_staff', true)->latest()->paginate(20);
        $roles = Role::orderBy('name')->get();

        return view('admin.staff.index', compact('staff', 'roles'));
    }

    public function store(Request $request)
    {
        $data = $request->validate([
            'name' => 'required|string|max:120',
            'email' => 'required|email|unique:users,email',
            'password' => 'required|string|min:8',
            'role_id' => 'required|exists:roles,id',
        ]);

        $user = User::create([
            'name' => $data['name'],
            'email' => $data['email'],
            'password' => Hash::make($data['password']),
            'account_type' => 'staff',
            'is_staff' => true,
            'status' => 'active',
            'kyc_level' => 0,
        ]);

        $user->roles()->attach($data['role_id']);
        AuditLogger::log('staff.create', $user, null, $user->only(['name', 'email']));

        return back()->with('success', 'Staff member created.');
    }

    public function updateRoles(Request $request, User $user)
    {
        abort_unless($user->is_staff, 404);

        $data = $request->validate([
            'role_ids' => 'array',
            'role_ids.*' => 'exists:roles,id',
        ]);

        $user->roles()->sync($data['role_ids'] ?? []);
        AuditLogger::log('staff.roles_update', $user, null, ['role_ids' => $data['role_ids'] ?? []]);

        return back()->with('success', 'Staff roles updated.');
    }
}
'''

controllers["Audit/Controllers/AuditController.php"] = r'''<?php

namespace App\Modules\Audit\Controllers;

use App\Http\Controllers\Controller;
use App\Models\AuditLog;
use Illuminate\Http\Request;

class AuditController extends Controller
{
    public function index(Request $request)
    {
        $query = AuditLog::with('admin')->latest();
        if ($action = $request->get('action')) {
            $query->where('action', 'like', "%{$action}%");
        }
        $logs = $query->paginate(30)->withQueryString();

        return view('admin.audit.index', compact('logs'));
    }

    public function show(AuditLog $audit)
    {
        $audit->load('admin');

        return view('admin.audit.show', compact('audit'));
    }
}
'''

controllers["Settings/Controllers/SettingController.php"] = r'''<?php

namespace App\Modules\Settings\Controllers;

use App\Http\Controllers\Controller;
use App\Models\PlatformSetting;
use App\Services\AuditLogger;
use Illuminate\Http\Request;

class SettingController extends Controller
{
    public function index()
    {
        $settings = PlatformSetting::orderBy('group')->orderBy('key')->get()->groupBy('group');

        return view('admin.settings.index', compact('settings'));
    }

    public function update(Request $request)
    {
        $data = $request->validate([
            'settings' => 'required|array',
        ]);

        foreach ($data['settings'] as $key => $value) {
            PlatformSetting::where('key', $key)->update(['value' => $value]);
        }

        AuditLogger::log('settings.update', null, null, $data['settings']);

        return back()->with('success', 'Settings saved.');
    }
}
'''

for rel, content in controllers.items():
    path = ROOT / "app/Modules" / rel
    path.parent.mkdir(parents=True, exist_ok=True)
    path.write_text(content)
    print("Wrote", rel)

print("Controllers:", len(controllers))