<?php

namespace App\Http\Controllers;

use App\Http\Requests\Auth\LoginRequest;
use App\Mail\Welcome;
use App\Models\Package;
use App\Models\PackagePurchase;
use App\Models\Tenant;
use App\Models\TenantPackage;
use App\Models\User;
use Illuminate\Auth\Events\Registered;
use Illuminate\Http\JsonResponse;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Auth;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Hash;
use Illuminate\Support\Facades\Mail;
use Illuminate\Support\Str;
use Illuminate\Validation\Rules;
use Illuminate\Validation\ValidationException;
use Inertia\Response;
use Throwable;

class CheckoutController extends Controller
{
    /**
     * Render the checkout wizard using the legacy marketing controller for now.
     */
    public function show(Request $request, Package $package): Response
    {
        $marketingController = app(MarketingController::class);

        return $marketingController->purchaseWizard($request, $package->getKey());
    }

    public function login(LoginRequest $request): JsonResponse
    {
        app()->setLocale($request->input('locale', app()->getLocale()));

        $request->authenticate();
        $request->session()->regenerate();

        $user = $request->user()?->fresh();

        return response()->json([
            'success' => true,
            'user' => $this->transformUser($user),
        ]);
    }

    public function register(Request $request): JsonResponse
    {
        app()->setLocale($request->input('locale', app()->getLocale()));

        try {
            $validated = $request->validate([
                'username' => ['required', 'string', 'max:255', 'unique:'.User::class],
                'email' => ['required', 'string', 'lowercase', 'email', 'max:255', 'unique:'.User::class],
                'password' => ['required', 'confirmed', Rules\Password::defaults()],
                'first_name' => ['required', 'string', 'max:255'],
                'last_name' => ['required', 'string', 'max:255'],
                'address' => ['required', 'string', 'max:500'],
                'phone' => ['required', 'string', 'max:20'],
                'privacy_consent' => ['accepted'],
                'package_id' => ['nullable', 'integer'],
            ]);
        } catch (ValidationException $exception) {
            throw $exception;
        }

        $shouldAutoVerify = app()->environment(['local', 'testing']);

        DB::beginTransaction();

        try {
            $user = User::create([
                'username' => $validated['username'],
                'email' => $validated['email'],
                'first_name' => $validated['first_name'],
                'last_name' => $validated['last_name'],
                'address' => $validated['address'],
                'phone' => $validated['phone'],
                'password' => bcrypt($validated['password']),
                'role' => 'user',
                'pending_purchase' => !empty($validated['package_id']),
            ]);

            if ($user->pending_purchase) {
                $request->session()->put('pending_user_id', $user->id);
            }

            if ($shouldAutoVerify) {
                $user->forceFill(['email_verified_at' => now()])->save();
            }

            $tenant = Tenant::create([
                'user_id' => $user->id,
                'name' => $validated['first_name'].' '.$validated['last_name'],
                'slug' => Str::slug($validated['first_name'].' '.$validated['last_name'].'-'.now()->timestamp),
                'email' => $validated['email'],
                'is_active' => true,
                'is_suspended' => false,
                'event_credits_balance' => 0,
                'subscription_tier' => 'free',
                'subscription_expires_at' => null,
                'settings' => json_encode([
                    'branding' => [
                        'logo_url' => null,
                        'primary_color' => '#3B82F6',
                        'secondary_color' => '#1F2937',
                        'font_family' => 'Inter, sans-serif',
                    ],
                    'features' => [
                        'photo_likes_enabled' => false,
                        'event_checklist' => false,
                        'custom_domain' => false,
                        'advanced_analytics' => false,
                    ],
                    'custom_domain' => null,
                    'contact_email' => $validated['email'],
                    'event_default_type' => 'general',
                ]),
            ]);

            event(new Registered($user));

            Auth::login($user);
            $request->session()->regenerate();

            DB::commit();

            Mail::to($user)->queue(new Welcome($user));

            $redirect = $shouldAutoVerify ? route('dashboard') : route('verification.notice');
            $pendingPurchase = $user->pending_purchase;

            if (!empty($validated['package_id'])) {
                $package = Package::find($validated['package_id']);

                if (!$package) {
                    throw ValidationException::withMessages([
                        'package_id' => __('validation.exists', ['attribute' => 'package'])
                    ]);
                }

                if ((float) $package->price <= 0.0) {
                    TenantPackage::create([
                        'tenant_id' => $tenant->id,
                        'package_id' => $package->id,
                        'price' => 0,
                        'active' => true,
                    ]);

                    PackagePurchase::create([
                        'tenant_id' => $tenant->id,
                        'package_id' => $package->id,
                        'type' => $package->type === 'endcustomer' ? 'endcustomer_event' : 'reseller_subscription',
                        'price' => 0,
                        'purchased_at' => now(),
                        'provider_id' => 'free',
                    ]);

                    $tenant->update(['subscription_status' => 'active']);
                    $user->update(['role' => 'tenant_admin', 'pending_purchase' => false]);
                    $pendingPurchase = false;
                    $redirect = $shouldAutoVerify ? route('dashboard') : route('verification.notice');
                } else {
                    $pendingPurchase = true;
                    $redirect = route('buy.packages', $package->id);
                }
            }

            $freshUser = $user->fresh();

            return response()->json([
                'success' => true,
                'user' => $this->transformUser($freshUser),
                'pending_purchase' => $pendingPurchase,
                'redirect' => $redirect,
            ]);
        } catch (ValidationException $validationException) {
            DB::rollBack();
            throw $validationException;
        } catch (Throwable $throwable) {
            DB::rollBack();
            report($throwable);

            return response()->json([
                'success' => false,
                'message' => __('auth.registration_failed'),
            ], 500);
        }
    }

    private function transformUser(?User $user): ?array
    {
        if (!$user) {
            return null;
        }

        return [
            'id' => $user->id,
            'email' => $user->email,
            'name' => trim(($user->first_name ?? '').' '.($user->last_name ?? '')) ?: $user->name,
            'pending_purchase' => (bool) $user->pending_purchase,
            'email_verified_at' => $user->email_verified_at,
        ];
    }
}