<?php

namespace App\Http\Controllers;

use App\Models\BillingItemType;
use App\Models\Client;
use App\Models\ClientCustomer;
use App\Models\ClientInvoice;
use App\Models\ClientUserAssignation;
use App\Services\ClientInvoiceApprovalService;
use App\Services\ClientInvoicePaymentSyncService;
use App\Services\ClientLookupService;
use App\Services\UserHierarchyService;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Auth;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Http;
use Illuminate\Support\Facades\Storage;
use Illuminate\Validation\Rule;
use Inertia\Inertia;
use Inertia\Response;
use Throwable;

class ClientInvoiceController extends Controller
{
    public function __construct(
        private ClientInvoiceApprovalService $approvalService,
        private ClientInvoicePaymentSyncService $paymentSyncService,
        private UserHierarchyService $hierarchyService,
        private ClientLookupService $clientLookupService,
    ) {}

    public function create(Request $request): Response
    {
        $clientId = $request->query('client');
        $customerId = $request->query('customer_id');

        if (! $clientId || ! $customerId) {
            abort(404);
        }

        $client = Client::findOrFail($clientId);
        abort_unless($this->hierarchyService->canViewClient(Auth::user(), $client), 403);

        $availableInvoices = ClientInvoice::query()
            ->where('client_id', $clientId)
            ->orderBy('invoice_no')
            ->get(['id', 'invoice_no', 'linked_invoice_id']);

        return Inertia::render('client-invoices/create', [
            'clientId' => $clientId,
            'customerId' => $customerId,
            'availableInvoices' => $availableInvoices,
            'billingItemTypes' => $this->billingItemTypesForForm(),
        ]);
    }

    public function edit(ClientInvoice $invoice): Response
    {
        $invoice->load('client');
        $resolvedClient = $invoice->client
            ?? $this->clientLookupService->findBySqlAccCode($invoice->pending_sql_acc_code);
        if ($resolvedClient !== null) {
            abort_unless($this->hierarchyService->canViewClient(Auth::user(), $resolvedClient), 403);
        }

        $availableInvoices = $resolvedClient === null
            ? collect()
            : ClientInvoice::query()
                ->where('client_id', $resolvedClient->id)
                ->where('id', '!=', $invoice->id)
                ->orderBy('invoice_no')
                ->get(['id', 'invoice_no', 'linked_invoice_id']);

        return Inertia::render('client-invoices/edit', [
            'invoice' => $invoice->load('client', 'payments.items.billingItemType'),
            'availableInvoices' => $availableInvoices,
            'billingItemTypes' => $this->billingItemTypesForForm(),
            'existingClient' => $invoice->client === null ? $resolvedClient : null,
            'unlinkedClients' => $this->clientOptions(),
        ]);
    }

    public function store(Request $request)
    {
        $validated = $request->validate([
            'client_id' => ['required', 'exists:clients,id'],
            'customer_id' => ['nullable', 'string'],
            'invoice_no' => ['required', 'string'],
            'linked_invoice_id' => [
                'nullable',
                'integer',
                Rule::exists('client_invoices', 'id')->where(function ($query) use ($request) {
                    return $query->where('client_id', $request->integer('client_id'));
                }),
            ],
            'is_paid' => ['nullable', 'boolean'],
            ...$this->paymentValidationRules(),
        ]);

        $client = Client::findOrFail($validated['client_id']);
        abort_unless($this->hierarchyService->canViewClient(Auth::user(), $client), 403);

        $invoice = DB::transaction(function () use ($validated) {
            $invoice = ClientInvoice::create([
                'client_id' => $validated['client_id'],
                'invoice_no' => $validated['invoice_no'],
                'linked_invoice_id' => $validated['linked_invoice_id'] ?? null,
                'approved_at' => null,
                'total_sem_amount' => $validated['total_sem_amount'] ?? 0,
                'total_net_amount' => $validated['total_net_amount'] ?? 0,
            ]);

            return $this->paymentSyncService->sync(
                $invoice,
                $this->paymentsPayload($validated, $invoice)
            );
        });

        $this->approvalService->approve($invoice);

        return redirect()
            ->route('google-ads.accounts.show', ['id' => $validated['customer_id'] ?? $client->customer_id])
            ->with('message-info', 'Invoice created successfully.');
    }

    public function update(Request $request, ClientInvoice $invoice)
    {
        $invoice->load('client');
        $resolvedClient = $invoice->client
            ?? $this->clientLookupService->findBySqlAccCode($invoice->pending_sql_acc_code);

        if ($resolvedClient !== null) {
            abort_unless($this->hierarchyService->canViewClient(Auth::user(), $resolvedClient), 403);
        }

        $validated = $request->validate([
            'client_id' => [
                'required',
                'integer',
                'exists:clients,id',
            ],
            'invoice_no' => ['required', 'string'],
            'linked_invoice_id' => [
                'nullable',
                'integer',
                Rule::exists('client_invoices', 'id')->where(function ($query) use ($request, $invoice) {
                    return $query
                        ->where('client_id', $request->integer('client_id') ?: $invoice->client_id)
                        ->where('id', '!=', $invoice->id);
                }),
            ],
            'is_paid' => ['nullable', 'boolean'],
            ...$this->paymentValidationRules(),
        ]);

        $invoice = DB::transaction(function () use ($invoice, $validated) {
            if ($invoice->client_id === null) {
                $this->linkInvoiceClient($invoice, $validated);
                $invoice->refresh();
            } elseif ($invoice->client_id !== (int) $validated['client_id']) {
                $client = Client::findOrFail($validated['client_id']);
                abort_unless($this->hierarchyService->canViewClient(Auth::user(), $client), 403);

                $invoice->update([
                    'client_id' => $client->id,
                    'pending_sql_acc_code' => null,
                    'pending_client_name' => null,
                    'linked_invoice_id' => null,
                ]);
                $invoice->refresh();
            }

            $invoice->update([
                'invoice_no' => $validated['invoice_no'],
                'linked_invoice_id' => $validated['linked_invoice_id'] ?? null,
                'total_sem_amount' => $validated['total_sem_amount'] ?? 0,
                'total_net_amount' => $validated['total_net_amount'] ?? 0,
            ]);

            return $this->paymentSyncService->sync(
                $invoice,
                $this->paymentsPayload($validated, $invoice)
            );
        });

        if (empty($invoice->approved_at)) {
            $this->approvalService->approve($invoice);
        }

        $invoice->load('client');

        return redirect()
            ->route('google-ads.accounts.show', ['id' => $invoice->client->customer_id])
            ->with('message-info', 'Invoice updated successfully.');
    }

    private function paymentValidationRules(): array
    {
        return [
            'payments' => ['nullable', 'array', 'min:1'],
            'payments.*.payment_no' => ['nullable', 'string'],
            'payments.*.payment_total_amount' => ['required_with:payments', 'numeric', 'min:0'],
            'payments.*.payment_nett_amount' => ['required_with:payments', 'numeric', 'min:0'],
            'payments.*.items' => ['required_with:payments', 'array', 'min:1'],
            'payments.*.items.*.billing_item_types_id' => ['required_with:payments', 'integer', 'exists:billing_item_types,id'],
            'payments.*.items.*.start_date' => ['nullable', 'date'],
            'payments.*.items.*.end_date' => ['nullable', 'date'],
            'payments.*.items.*.payment_item_amount' => ['required_with:payments', 'numeric', 'min:0'],
            'payments.*.items.*.tax_percentage' => ['required_with:payments', 'numeric', 'min:0', 'max:100'],
            'payments.*.items.*.net_amount' => ['required_with:payments', 'numeric', 'min:0'],
            'payments.*.items.*.withholding_tax' => ['nullable', 'numeric', 'min:0', 'max:100'],
            'payments.*.items.*.final_net_amount' => ['required_with:payments', 'numeric', 'min:0'],
            'payments.*.items.*.spending' => ['nullable', 'numeric', 'min:0'],
            'payments.*.items.*.is_creditcard' => ['nullable', 'boolean'],
            'payment_no' => ['nullable', 'string'],
            'start_date' => ['nullable', 'date'],
            'end_date' => ['nullable', 'date', 'after_or_equal:start_date'],
            'is_credit_card' => ['nullable', 'boolean'],
            'total_sem_amount' => ['nullable', 'numeric', 'min:0'],
            'total_net_amount' => ['nullable', 'numeric', 'min:0'],
            'amount' => ['nullable', 'numeric', 'min:0'],
            'management_fee' => ['required_without:payments', 'numeric', 'min:0'],
            'management_fee_amount' => ['nullable', 'numeric', 'min:0'],
            'management_fee_tax' => ['nullable', 'numeric', 'min:0'],
            'media_fee' => ['required_without:payments', 'numeric', 'min:0'],
            'media_fee_amount' => ['nullable', 'numeric', 'min:0'],
            'media_fee_tax' => ['nullable', 'numeric', 'min:0'],
            'tax_percent' => ['nullable', 'numeric', 'min:0', 'max:100'],
            'nett_amount' => ['nullable', 'numeric', 'min:0'],
            'total_spending' => ['nullable', 'numeric', 'min:0'],
        ];
    }

    private function paymentsPayload(array $validated, ClientInvoice $invoice): array
    {
        if (! empty($validated['payments'])) {
            return $validated['payments'];
        }

        $billingItemTypes = $this->paymentSyncService->ensureDefaultItemTypes()->keyBy('name');
        $taxPercent = (float) ($validated['tax_percent'] ?? 0);
        $mediaFee = (float) ($validated['media_fee'] ?? 0);
        $mediaFeeAmount = (float) ($validated['media_fee_amount'] ?? $this->netFromGross($mediaFee, $taxPercent));
        $managementFee = (float) ($validated['management_fee'] ?? 0);
        $managementFeeAmount = (float) ($validated['management_fee_amount'] ?? $this->netFromGross($managementFee, $taxPercent));
        $items = [];

        if ($mediaFee > 0) {
            $items[] = [
                'billing_item_types_id' => $billingItemTypes[ClientInvoicePaymentSyncService::MEDIA_SEARCH_NAME]->id,
                'start_date' => $validated['start_date'] ?? null,
                'end_date' => $validated['end_date'] ?? null,
                'payment_item_amount' => $mediaFee,
                'tax_percentage' => $taxPercent,
                'net_amount' => $mediaFeeAmount,
                'withholding_tax' => 0,
                'final_net_amount' => $validated['nett_amount'] ?? $mediaFeeAmount,
                'spending' => $validated['total_spending'] ?? 0,
                'is_creditcard' => (bool) ($validated['is_credit_card'] ?? false),
            ];
        }

        if ($managementFee > 0) {
            $items[] = [
                'billing_item_types_id' => $billingItemTypes[ClientInvoicePaymentSyncService::MANAGEMENT_SEARCH_NAME]->id,
                'start_date' => null,
                'end_date' => null,
                'payment_item_amount' => $managementFee,
                'tax_percentage' => $taxPercent,
                'net_amount' => $managementFeeAmount,
                'withholding_tax' => 0,
                'final_net_amount' => $managementFeeAmount,
                'spending' => 0,
                'is_creditcard' => false,
            ];
        }

        return [[
            'payment_no' => $validated['payment_no'] ?? null,
            'payment_total_amount' => $mediaFee + $managementFee,
            'payment_nett_amount' => $this->netFromGross($mediaFee + $managementFee, $taxPercent),
            'items' => $items,
        ]];
    }

    private function billingItemTypesForForm(): array
    {
        $this->paymentSyncService->ensureDefaultItemTypes();

        return BillingItemType::query()
            ->orderBy('id')
            ->get(['id', 'name', 'sql_acc_code', 'nett_contribution', 'fee_type', 'type', 'campaign_type'])
            ->map(fn (BillingItemType $itemType) => [
                'id' => $itemType->id,
                'name' => $itemType->name,
                'sql_acc_code' => $itemType->sql_acc_code,
                'nett_contribution' => $itemType->nett_contribution,
                'fee_type' => $itemType->fee_type,
                'type' => $itemType->type,
                'campaign_type' => $itemType->campaign_type,
            ])
            ->all();
    }

    private function netFromGross(float $grossAmount, float $taxPercent): float
    {
        return $taxPercent > 0
            ? $grossAmount / (1 + ($taxPercent / 100))
            : $grossAmount;
    }

    private function unlinkedClientOptions(): array
    {
        return Client::query()
            ->where(function ($query) {
                $query->whereNull('sql_acc_code')
                    ->orWhere('sql_acc_code', '');
            })
            ->orderBy('name')
            ->get(['id', 'name', 'customer_id', 'status', 'time_zone'])
            ->map(fn (Client $client) => [
                'value' => (string) $client->id,
                'label' => trim($client->name.' ('.$client->customer_id.')'),
            ])
            ->values()
            ->all();
    }

    private function clientOptions(): array
    {
        return Client::query()
            ->orderBy('name')
            ->get(['id', 'name', 'customer_id', 'status', 'time_zone'])
            ->map(fn (Client $client) => [
                'value' => (string) $client->id,
                'label' => trim($client->name.' ('.$client->customer_id.')'),
            ])
            ->values()
            ->all();
    }

    private function linkInvoiceClient(ClientInvoice $invoice, array $validated): Client
    {
        $client = Client::findOrFail($validated['client_id']);
        abort_unless($this->hierarchyService->canViewClient(Auth::user(), $client), 403);

        ClientUserAssignation::firstOrCreate(
            [
                'client_id' => $client->id,
                'role' => ClientUserAssignation::ROLE_ASSIGNED_PERSON,
                'user_id' => Auth::id(),
            ]
        );

        $invoice->update([
            'client_id' => $client->id,
            'pending_sql_acc_code' => null,
            'pending_client_name' => null,
        ]);

        return $client;
    }

    public function approve(ClientInvoice $invoice)
    {
        abort_if($invoice->client === null, 409, 'Create the client before approving this invoice.');
        abort_unless($this->hierarchyService->canViewClient(Auth::user(), $invoice->client), 403);

        $this->approvalService->approve($invoice);

        return redirect()
            ->back()
            ->with('message-info', 'Invoice approved successfully.');
    }

    public function destroy(ClientInvoice $invoice)
    {
        if ($invoice->client !== null) {
            abort_unless($this->hierarchyService->canViewClient(Auth::user(), $invoice->client), 403);
        }

        DB::transaction(function () use ($invoice) {
            $invoice->loadMissing('payments.items', 'linkedInvoices');

            $invoice->linkedInvoices()->update([
                'linked_invoice_id' => null,
            ]);

            $invoice->payments->each(function ($payment) {
                $payment->items()->delete();
                $payment->delete();
            });

            $invoice->delete();
        });

        return redirect()
            ->back()
            ->with('message-info', 'Invoice deleted successfully.');
    }

    public function getPdfInvoice($id)
    {
        $invoice = ClientInvoice::find($id);

        abort_if($invoice === null, 404, 'Invoice not found.');

        $this->authorizeInvoicePdfAccess($invoice);

        if ($this->storedInvoicePdfExists($invoice)) {
            return response()->file(
                Storage::disk('local')->path($invoice->pdf_path),
                [
                    'Content-Type' => 'application/pdf',
                    'Content-Disposition' => 'inline; filename="invoice-'.$invoice->id.'.pdf"',
                ],
            );
        }

        $pdfUrl = $this->externalInvoicePdfUrl($invoice);

        abort_if($pdfUrl === null, 404, 'Invoice PDF not found.');

        $response = Http::withHeaders([
            'X-Secret' => config('app.billing_key'),
            'Accept' => 'application/json',
        ])->get($pdfUrl);

        if ($response->status() === 404) {
            abort(404, 'Invoice PDF not found.');
        }

        abort_unless($response->successful(), 502, 'Unable to fetch invoice PDF.');

        return response()->stream(
            function () use ($response) {
                echo $response->body();
            },
            200,
            [
                'Content-Type' => 'application/pdf',
            ],
        );
    }

    public function pdfInvoiceStatus(ClientInvoice $invoice)
    {
        $this->authorizeInvoicePdfAccess($invoice);

        if ($this->storedInvoicePdfExists($invoice)) {
            return response()->json([
                'available' => true,
                'source' => 'uploaded',
                'pdf_url' => route('client-invoices.getPdfInvoice', ['id' => $invoice->id]),
            ]);
        }

        if ($this->externalInvoicePdfUrl($invoice) !== null) {
            return response()->json([
                'available' => true,
                'source' => 'external',
                'pdf_url' => route('client-invoices.getPdfInvoice', ['id' => $invoice->id]),
            ]);
        }

        return response()->json([
            'available' => false,
            'message' => 'Invoice PDF not found.',
        ], 404);
    }

    public function uploadPdfInvoice(Request $request, ClientInvoice $invoice)
    {
        $this->authorizeInvoicePdfAccess($invoice);

        $validated = $request->validate([
            'invoice_pdf' => ['required', 'file', 'mimes:pdf', 'max:20480'],
        ]);

        if ($this->storedInvoicePdfExists($invoice)) {
            Storage::disk('local')->delete($invoice->pdf_path);
        }

        $path = $validated['invoice_pdf']->store('client-invoices/'.$invoice->id, 'local');

        $invoice->update([
            'pdf_path' => $path,
        ]);

        return response()->json([
            'message' => 'Invoice uploaded successfully.',
            'pdf_url' => route('client-invoices.getPdfInvoice', ['id' => $invoice->id]),
        ]);
    }

    private function authorizeInvoicePdfAccess(ClientInvoice $invoice): void
    {
        $invoice->loadMissing('client');

        if ($invoice->client !== null) {
            abort_unless($this->hierarchyService->canViewClient(Auth::user(), $invoice->client), 403);
        }
    }

    private function storedInvoicePdfExists(ClientInvoice $invoice): bool
    {
        return ! empty($invoice->pdf_path)
            && Storage::disk('local')->exists($invoice->pdf_path);
    }

    private function externalInvoicePdfUrl(ClientInvoice $invoice): ?string
    {
        if (empty($invoice->invoice_no)) {
            return null;
        }

        try {
            $invoiceResponse = Http::acceptJson()
                ->withHeaders([
                    'X-Secret' => config('app.billing_key'),
                    'Accept' => 'application/json',
                ])
                ->get(config('app.billing_url').'/customer/invoices/', [
                    'audience' => 'SEM',
                    'invoice_numbers' => [$invoice->invoice_no],
                ]);
        } catch (Throwable) {
            return null;
        }

        if (! $invoiceResponse->successful()) {
            return null;
        }

        $invoiceDetails = $invoiceResponse->json();
        $pdfUrl = data_get($invoiceDetails, 'data.0.pdf_url');

        return is_string($pdfUrl) && $pdfUrl !== '' ? $pdfUrl : null;
    }

    public function createClient(ClientInvoice $invoice): Response|\Illuminate\Http\RedirectResponse
    {
        $existingClient = $invoice->client
            ?? $this->clientLookupService->findBySqlAccCode($invoice->pending_sql_acc_code);

        if ($existingClient !== null) {
            $invoice->update([
                'client_id' => $existingClient->id,
                'pending_sql_acc_code' => null,
                'pending_client_name' => null,
            ]);

            return redirect()
                ->route('client-invoices.edit', $invoice)
                ->with('message-info', 'Invoice '.$invoice->invoice_no.' has been linked to '.$existingClient->name.'.');
        }

        return Inertia::render('client-invoices/create-client', [
            'invoice' => $invoice->load('client'),
            'existingClient' => null,
            'unlinkedClients' => $this->unlinkedClientOptions(),
        ]);
    }

    public function storeClient(Request $request, ClientInvoice $invoice)
    {
        $validated = $request->validate([
            'client_id' => [
                'required',
                Rule::exists('clients', 'id')->where(function ($query) {
                    $query
                        ->where(function ($query) {
                            $query->whereNull('sql_acc_code')
                                ->orWhere('sql_acc_code', '');
                        });
                }),
            ],
            'sql_acc_code' => ['required', 'string'],
        ]);

        $sqlAccCode = $this->clientLookupService->normalizeSqlAccCode($validated['sql_acc_code']);
        $existingClient = $this->clientLookupService->findBySqlAccCode($sqlAccCode);

        if ($existingClient !== null && $existingClient->id !== (int) $validated['client_id']) {
            return redirect()
                ->back()
                ->withInput()
                ->withErrors(['sql_acc_code' => 'This SQL account code is already linked to another client.']);
        }

        $selectedClientIsLinked = Client::query()
            ->where('id', $validated['client_id'])
            ->where(function ($query) {
                $query->whereNotNull('sql_acc_code')
                    ->where('sql_acc_code', '!=', '');
            })
            ->exists();

        if ($selectedClientIsLinked) {
            return redirect()
                ->back()
                ->withInput()
                ->withErrors(['client_id' => 'Select a client that does not already have an SQL account code.']);
        }

        $client = DB::transaction(function () use ($validated, $sqlAccCode, $invoice) {
            $client = Client::findOrFail($validated['client_id']);

            $client->update([
                'sql_acc_code' => $sqlAccCode,
            ]);

            ClientCustomer::updateOrCreate(
                [
                    'client_id' => $client->id,
                    'sql_acc_code' => $sqlAccCode,
                ],
                []
            );

            ClientUserAssignation::firstOrCreate(
                [
                    'client_id' => $client->id,
                    'role' => ClientUserAssignation::ROLE_ASSIGNED_PERSON,
                    'user_id' => Auth::id(),
                ]
            );

            $invoice->update([
                'client_id' => $client->id,
                'pending_sql_acc_code' => null,
                'pending_client_name' => null,
            ]);

            return $client;
        });

        return redirect()
            ->route('client-invoices.edit', $invoice)
            ->with('message-info', 'Client '.$client->name.' has been linked to invoice '.$invoice->invoice_no.'.');
    }
}