<?php

namespace App\Http\Controllers\Admin;

use App\Http\Controllers\Controller;
use Illuminate\Http\Request;
use App\Models\Order;
use App\Models\OrderItem;
use App\Models\MarkList;
use App\Models\Invoice;
use App\Models\InvoiceItem;
use App\Models\User;

class AdminOrderController extends Controller
{
    // ---------------------------
    // LIST / DASHBOARD
    // ---------------------------
    public function index()
    {
        // raw list for admin dashboard (simple)
        $orders = Order::latest()->get();
        $markList = MarkList::where('status', 'active')->get();

        return view('admin.dashboard', compact('orders', 'markList'));
    }

    /**
     * Orders list (detailed)
     */
    // public function orderShow()
    // {
    //     $orders = Order::with(['markList', 'shipments', 'invoice'])
    //         ->latest('id')
    //         ->get();

    //     return view('admin.orders', compact('orders'));
    // }

    // ---------------------------
    // CREATE NEW ORDER (simple DB flow)
    // ---------------------------
    /**
     * Show create form (you can place create UI on separate view or dashboard)
     */
    public function create()
    {
        // return a dedicated create view - create it at resources/views/admin/orders_create.blade.php
        // If you prefer create UI on dashboard, change this to redirect route('admin.orders.index') etc.
        $markList = MarkList::where('status', 'active')->get();
        return view('admin.orders_create', compact('markList'));
    }

    /**
     * Store a new order and optionally create initial invoice
     */
    public function store(Request $request)
    {
        $data = $request->validate([
            'mark_no' => 'required|string',
            'origin' => 'nullable|string',
            'destination' => 'nullable|string',
            // totals optional when creating without items
            'ctn' => 'nullable|numeric',
            'qty' => 'nullable|numeric',
            'ttl_qty' => 'nullable|numeric',
            'ttl_amount' => 'nullable|numeric',
            'cbm' => 'nullable|numeric',
            'ttl_cbm' => 'nullable|numeric',
            'kg' => 'nullable|numeric',
            'ttl_kg' => 'nullable|numeric',
        ]);

        $order = Order::create([
            'order_id' => $this->generateOrderId(),
            'mark_no' => $data['mark_no'],
            'origin' => $data['origin'] ?? null,
            'destination' => $data['destination'] ?? null,
            'ctn' => $data['ctn'] ?? 0,
            'qty' => $data['qty'] ?? 0,
            'ttl_qty' => $data['ttl_qty'] ?? 0,
            'ttl_amount' => $data['ttl_amount'] ?? 0,
            'cbm' => $data['cbm'] ?? 0,
            'ttl_cbm' => $data['ttl_cbm'] ?? 0,
            'kg' => $data['kg'] ?? 0,
            'ttl_kg' => $data['ttl_kg'] ?? 0,
            'status' => 'pending',
        ]);

        // If you want to auto-create an invoice at order creation, uncomment:
        // $this->createInvoice($order);

        return redirect()->route('admin.orders.show', $order->id)
                         ->with('success', 'Order created successfully.');
    }

    // ---------------------------
    // SHOW / POPUP
    // ---------------------------
    public function show($id)
    {
        $order = Order::with('items', 'markList')->findOrFail($id);
        $user = $this->getCustomerFromOrder($order);

        return view('admin.orders_show', compact('order', 'user'));
    }

    // public function popup($id)
    // {
    //     $order = Order::with(['items', 'markList'])->findOrFail($id);
    //     $user = $this->getCustomerFromOrder($order);

    //     return view('admin.popup', compact('order', 'user'));
    // }

    // ---------------------------
    // ORDER ITEM MANAGEMENT (DB)
    // ---------------------------
    /**
     * Add an item to an existing order
     */
    public function addItem(Request $request, $orderId)
    {
        $order = Order::findOrFail($orderId);

        $data = $request->validate([
            'description' => 'required|string',
            'ctn' => 'nullable|numeric',
            'qty' => 'nullable|numeric',
            'ttl_qty' => 'nullable|numeric',
            'unit' => 'nullable|string',
            'price' => 'nullable|numeric',
            'ttl_amount' => 'nullable|numeric',
            'cbm' => 'nullable|numeric',
            'ttl_cbm' => 'nullable|numeric',
            'kg' => 'nullable|numeric',
            'ttl_kg' => 'nullable|numeric',
            'shop_no' => 'nullable|string',
        ]);

        $data['order_id'] = $order->id;

        OrderItem::create($data);

        // recalc totals and save to order
        $this->recalcTotals($order);

        return redirect()->back()->with('success', 'Item added and totals updated.');
    }

    /**
     * Soft-delete an order item and recalc totals
     */
    public function deleteItem($id)
    {
        $item = OrderItem::findOrFail($id);
        $order = $item->order;

        $item->delete(); // soft delete

        // recalc totals
        $this->recalcTotals($order);

        return redirect()->back()->with('success', 'Item deleted and totals updated.');
    }

    /**
     * Restore soft-deleted item and recalc totals
     */
    public function restoreItem($id)
    {
        $item = OrderItem::withTrashed()->findOrFail($id);
        $order = Order::findOrFail($item->order_id);

        $item->restore();

        // recalc totals
        $this->recalcTotals($order);

        return redirect()->back()->with('success', 'Item restored and totals updated.');
    }

    // ---------------------------
    // ORDER CRUD: update / destroy
    // ---------------------------
    public function update(Request $request, $id)
    {
        $order = Order::findOrFail($id);

        $data = $request->validate([
            'mark_no' => 'required|string',
            'origin' => 'nullable|string',
            'destination' => 'nullable|string',
        ]);

        $order->update([
            'mark_no' => $data['mark_no'],
            'origin' => $data['origin'] ?? null,
            'destination' => $data['destination'] ?? null,
        ]);

        // optionally recalc totals (not necessary unless you change item-level fields here)
        $this->recalcTotals($order);

        return redirect()->route('admin.orders.show', $order->id)
                         ->with('success', 'Order updated successfully.');
    }

    /**
     * Soft-delete whole order and its items (soft-delete items first then order)
     */
    public function destroy($id)
    {
        $order = Order::findOrFail($id);

        // soft-delete items first (so they show up in onlyTrashed for restore)
        OrderItem::where('order_id', $order->id)->delete();

        // then soft-delete order
        $order->delete();

        return redirect()->route('admin.orders.index')
                         ->with('success', 'Order deleted successfully.');
    }

    // ---------------------------
    // HELPERS
    // ---------------------------
    /**
     * Recalculate totals for the order from current (non-deleted) items
     */
    private function recalcTotals(Order $order)
    {
        // make sure we re-query live items (non-deleted)
        $items = $order->items()->get();

        $order->update([
            'ctn'       => (int) $items->sum(fn($i) => (int) ($i->ctn ?? 0)),
            'qty'       => (int) $items->sum(fn($i) => (int) ($i->qty ?? 0)),
            'ttl_qty'   => (int) $items->sum(fn($i) => (int) ($i->ttl_qty ?? 0)),
            'ttl_amount'=> (float) $items->sum(fn($i) => (float) ($i->ttl_amount ?? 0)),
            'cbm'       => (float) $items->sum(fn($i) => (float) ($i->cbm ?? 0)),
            'ttl_cbm'   => (float) $items->sum(fn($i) => (float) ($i->ttl_cbm ?? 0)),
            'kg'        => (float) $items->sum(fn($i) => (float) ($i->kg ?? 0)),
            'ttl_kg'    => (float) $items->sum(fn($i) => (float) ($i->ttl_kg ?? 0)),
        ]);
    }

    /**
     * Generate order id (keeps old format)
     */
    private function generateOrderId()
    {
        $year = date('y');
        $prefix = "KNT-$year-";

        $lastOrder = Order::latest('id')->first();
        $nextNumber = $lastOrder ? intval(substr($lastOrder->order_id, -8)) + 1 : 1;

        return $prefix . str_pad($nextNumber, 8, '0', STR_PAD_LEFT);
    }

    // ---------------------------
    // INVOICE CREATION (optional helper used by store/finish)
    // ---------------------------
    private function createInvoice(Order $order)
    {
        $invoiceNumber = $this->generateInvoiceNumber();
        $customer = $this->getCustomerFromMarkList($order->mark_no);
        $totalAmount = $order->ttl_amount;

        $invoice = Invoice::create([
            'order_id' => $order->id,
            'customer_id' => $customer->id ?? null,
            'mark_no' => $order->mark_no,
            'invoice_number' => $invoiceNumber,
            'invoice_date' => now(),
            'due_date' => now()->addDays(10),
            'payment_method' => null,
            'reference_no' => null,
            'status' => 'pending',
            'final_amount' => $totalAmount,
            'gst_percent' => 0,
            'gst_amount' => 0,
            'final_amount_with_gst' => $totalAmount,
            'customer_name' => $customer->customer_name ?? null,
            'company_name' => $customer->company_name ?? null,
            'customer_email' => $customer->email ?? null,
            'customer_mobile' => $customer->mobile_no ?? null,
            'customer_address' => $customer->address ?? null,
            'pincode' => $customer->pincode ?? null,
            'notes' => null,
            'pdf_path' => null,
        ]);

        // clone order items into invoice items
        foreach ($order->items as $item) {
            InvoiceItem::create([
                'invoice_id' => $invoice->id,
                'description' => $item->description,
                'ctn' => $item->ctn,
                'qty' => $item->qty,
                'ttl_qty' => $item->ttl_qty,
                'unit' => $item->unit,
                'price' => $item->price,
                'ttl_amount' => $item->ttl_amount,
                'cbm' => $item->cbm,
                'ttl_cbm' => $item->ttl_cbm,
                'kg' => $item->kg,
                'ttl_kg' => $item->ttl_kg,
                'shop_no' => $item->shop_no,
            ]);
        }
    }

    private function generateInvoiceNumber()
    {
        $lastInvoice = Invoice::latest()->first();
        $nextInvoice = $lastInvoice ? $lastInvoice->id + 1 : 1;

        return 'INV-' . date('Y') . '-' . str_pad($nextInvoice, 6, '0', STR_PAD_LEFT);
    }

    private function getCustomerFromMarkList($markNo)
    {
        $markList = MarkList::where('mark_no', $markNo)->first();

        if ($markList && $markList->customer_id) {
            return User::where('customer_id', $markList->customer_id)->first();
        }

        return null;
    }

    private function getCustomerFromOrder($order)
    {
        if ($order->markList && $order->markList->customer_id) {
            return User::where('customer_id', $order->markList->customer_id)->first();
        }

        return null;
    }

    public function popup($id)
    {
        // Load order with items + markList
        $order = Order::with(['items', 'markList'])->findOrFail($id);

        // Fetch user based on markList customer_id (same as show method)
        $user = null;
        if ($order->markList && $order->markList->customer_id) {
            $user = \App\Models\User::where('customer_id', $order->markList->customer_id)->first();
        }

        return view('admin.popup', compact('order', 'user'));
    }


    public function resetTemp()
    {
        session()->forget(['temp_order_items', 'mark_no', 'origin', 'destination']);

        return redirect()->to(route('admin.orders.index') . '#createOrderForm')
                        ->with('success', 'Order reset successfully.');
    }

    public function orderShow()
    {
        $orders = Order::with([
            'markList',     // company, customer, origin, destination, date
            'shipments',    // shipment_id, shipment_date, status
            'invoice'       // invoice number, dates, amounts, status
        ])
        ->latest('id') // show latest orders first
        ->get();

        return view('admin.orders', compact('orders'));
    }
    
public function downloadPdf(Request $request)
{
    $query = Order::with(['markList', 'invoice', 'shipments']);
    
    // Apply filters
    if ($request->has('search') && $request->search) {
        $search = $request->search;
        $query->where(function($q) use ($search) {
            $q->where('order_id', 'like', "%{$search}%")
              ->orWhereHas('markList', function($q) use ($search) {
                  $q->where('company_name', 'like', "%{$search}%");
              })
              ->orWhereHas('invoice', function($q) use ($search) {
                  $q->where('invoice_number', 'like', "%{$search}%");
              });
        });
    }
    
    if ($request->has('status') && $request->status) {
        $query->whereHas('invoice', function($q) use ($request) {
            $q->where('status', $request->status);
        });
    }
    
    if ($request->has('shipment') && $request->shipment) {
        $query->whereHas('shipments', function($q) use ($request) {
            $q->where('status', $request->shipment);
        });
    }
    
    $orders = $query->get();
    
    $pdf = PDF::loadView('admin.orders.pdf', compact('orders'));
    return $pdf->download('orders-report-' . date('Y-m-d') . '.pdf');
}

public function downloadExcel(Request $request)
{
    return Excel::download(new OrdersExport($request), 'orders-report-' . date('Y-m-d') . '.xlsx');
}

}