
from datetime import datetime
from decimal import Decimal, InvalidOperation
import json
import uuid

from flask import (
    Blueprint,
    flash,
    redirect,
    render_template,
    request,
    url_for,
    session,
)

from sqlalchemy import func

from extensions import db
from models import (
    Order,
    OrderItem,
    OrderStatusHistory,
    Delivery,
    DeliveryZone,
    ProductVariant,
    StockReservation,
    Backorder,
    BackorderItem,
    BackorderHistory,
    Payment,
    PaymentTransaction,
)
from security import admin_required

from services.mopay import (
    create_payment_session,
    verify_payment_session,
    MoPayError,
    MoPayConfigurationError,
)


backorders_bp = Blueprint("backorders", __name__)

ADMIN_BACKORDER_STATUSES = {
    "awaiting_stock",
    "stock_ordered",
    "stock_received",
    "cancelled",
}

MOPAY_REDIRECT_URL = (
    "https://test-host.co.ls/delectables/backorders/payment-complete"
)


# ============================================================
# HELPERS
# ============================================================

def get_available_stock(variant, now=None):
    """
    Calculate stock available for new straight orders.

    Active, unexpired website reservations are excluded.
    """

    if now is None:
        now = datetime.utcnow()

    reserved_quantity = (
        db.session.query(
            func.coalesce(func.sum(StockReservation.quantity), 0)
        )
        .filter(
            StockReservation.variant_id == variant.id,
            StockReservation.status == "active",
            StockReservation.expires_at > now,
        )
        .scalar()
    )

    physical_stock = variant.stock_quantity or 0

    return max(
        0,
        physical_stock - int(reserved_quantity or 0)
    )


def set_pending_order(order):
    """
    Allow the current browser to access its order confirmation.
    """

    session["pending_order_number"] = order.order_number


def order_confirmation_redirect(order):
    set_pending_order(order)

    return redirect(
        url_for(
            "checkout.order_confirmation",
            order_number=order.order_number,
        )
    )


def record_backorder_payment_transaction(payment, reference):
    """
    Create the initial MoPay transaction before contacting
    the gateway.

    No cart session is associated with a backorder.
    """

    transaction = PaymentTransaction(
        payment_id=payment.id,
        transaction_reference=reference,
        gateway="mopay",
        request_data=json.dumps({
            "reference": reference,
            "amount": str(payment.amount),
            "order_source": "backorder",
        }),
        response_data="{}",
        status="initiating",
    )

    db.session.add(transaction)

    return transaction


def get_backorder_payment_records(reference):
    """
    Retrieve the payment, transaction, order and backorder
    associated with a MoPay reference.
    """

    transaction = PaymentTransaction.query.filter_by(
        gateway="mopay",
        transaction_reference=reference,
    ).first()

    if not transaction:
        return None, None, None, None

    payment = db.session.get(
        Payment,
        transaction.payment_id,
    )

    if not payment:
        return transaction, None, None, None

    order = db.session.get(
        Order,
        payment.order_id,
    )

    if not order or order.order_source != "backorder":
        return transaction, payment, order, None

    backorder = Backorder.query.filter_by(
        order_id=order.id,
    ).first()

    return transaction, payment, order, backorder


# ============================================================
# NEW BACKORDER PAGE
# ============================================================

@backorders_bp.route("/backorders/new", methods=["GET"])
def new_backorder():

    try:
        variant_id = int(request.args.get("variant_id", ""))
        quantity = int(request.args.get("quantity", ""))
    except (TypeError, ValueError):
        flash("Please select a valid product and quantity.", "error")
        return redirect(request.referrer or "/")

    if quantity < 1:
        flash("Please select a valid quantity.", "error")
        return redirect(request.referrer or "/")

    variant = ProductVariant.query.get(variant_id)

    if not variant or not variant.is_available:
        flash("This product option is currently unavailable.", "error")
        return redirect(request.referrer or "/")

    product = variant.product

    if not product or not product.is_active:
        flash("This product is currently unavailable.", "error")
        return redirect(request.referrer or "/")

    # Check whether this product allows backorders.
    if not product.allow_backorders:
        flash("Backorders are not available for this product.", "error")
        return redirect(request.referrer or "/")

    available_stock = get_available_stock(variant)

    if available_stock > 0:
        flash(
            "This product is available in stock. Please use the normal checkout.",
            "error",
        )
        return redirect(request.referrer or "/")

    delivery_zones = (
        DeliveryZone.query
        .filter_by(is_active=True)
        .order_by(DeliveryZone.name.asc())
        .all()
    )

    return render_template(
        "backorders/new_backorder.html",
        variant=variant,
        product=product,
        quantity=quantity,
        delivery_zones=delivery_zones,
    )


# ============================================================
# PLACE BACKORDER AND START MOPAY PAYMENT
# ============================================================

@backorders_bp.route("/backorders/place", methods=["POST"])
def place_backorder():

    customer_name = request.form.get(
        "customer_name", ""
    ).strip()

    customer_phone = request.form.get(
        "customer_phone", ""
    ).strip()

    customer_email = request.form.get(
        "customer_email", ""
    ).strip() or None

    delivery_method = request.form.get(
        "delivery_method", ""
    ).strip().lower()

    delivery_address = request.form.get(
        "delivery_address", ""
    ).strip()

    delivery_notes = request.form.get(
        "delivery_notes", ""
    ).strip()

    agreed_to_wait = request.form.get(
        "agreed_to_wait"
    ) == "on"

    try:
        variant_id = int(request.form.get("variant_id", ""))
        quantity = int(request.form.get("quantity", ""))
    except (TypeError, ValueError):
        flash("Please select a valid product and quantity.", "error")
        return redirect(request.referrer or url_for("home.index"))

    if not customer_name or not customer_phone:
        flash("Please provide your name and phone number.", "error")
        return redirect(request.referrer or url_for("home.index"))

    if quantity < 1:
        flash("The requested quantity must be at least one.", "error")
        return redirect(request.referrer or url_for("home.index"))

    if not agreed_to_wait:
        flash(
            "Please confirm that you agree to wait for stock replenishment.",
            "error",
        )
        return redirect(request.referrer or url_for("home.index"))

    if delivery_method not in ("delivery", "pickup"):
        flash("Please select delivery or collection.", "error")
        return redirect(request.referrer or url_for("home.index"))

    delivery_fee = Decimal("10.00")

    if delivery_method == "delivery":

        if not delivery_address:
            flash("Please provide your delivery address.", "error")
            return redirect(request.referrer or url_for("home.index"))

        try:
            zone_id = int(request.form.get("delivery_zone_id", ""))
        except (TypeError, ValueError):
            flash("Please select a valid delivery zone.", "error")
            return redirect(request.referrer or url_for("home.index"))

        zone = DeliveryZone.query.filter_by(
            id=zone_id,
            is_active=True,
        ).first()

        if not zone:
            flash("The selected delivery zone is unavailable.", "error")
            return redirect(request.referrer or url_for("home.index"))

        delivery_fee = Decimal(str(zone.fee or "0.00"))

    try:

        variant = (
            ProductVariant.query
            .filter_by(id=variant_id)
            .with_for_update()
            .first()
        )

        if not variant or not variant.is_available:
            raise ValueError(
                "This product option is currently unavailable."
            )

        product = variant.product

        if not product or not product.is_active:
            raise ValueError(
                "This product is currently unavailable."
            )

        # Recheck the product's backorder setting before accepting.
        if not product.allow_backorders:
            raise ValueError(
                "Backorders are not available for this product."
            )

        if get_available_stock(variant) > 0:
            raise ValueError(
                "This product is available in stock. "
                "Please use the normal checkout."
            )

        unit_price = Decimal(str(variant.price))
        subtotal = unit_price * quantity
        total = subtotal + delivery_fee

        order_number = "GV" + uuid.uuid4().hex[:10].upper()

        order = Order(
            order_number=order_number,
            customer_name=customer_name,
            customer_email=customer_email,
            customer_phone=customer_phone,
            delivery_method=delivery_method,
            delivery_address=(
                delivery_address if delivery_method == "delivery" else None
            ),
            delivery_notes=delivery_notes or None,
            subtotal=subtotal,
            delivery_fee=delivery_fee,
            total=total,
            order_status="pending",
            payment_status="pending",
            order_source="backorder",
        )

        db.session.add(order)
        db.session.flush()

        # ----------------------------------------------------
        # CREATE ORDER ITEM
        # ----------------------------------------------------

        order_item = OrderItem(
            order_id=order.id,
            variant_id=variant.id,
            product_name=product.name,
            mass=variant.mass,
            quantity=quantity,
            unit_price=unit_price,
            subtotal=subtotal,
        )

        db.session.add(order_item)
        db.session.flush()

        # ----------------------------------------------------
        # CREATE BACKORDER
        # ----------------------------------------------------

        backorder = Backorder(
            order_id=order.id,
            status="awaiting_stock",
            customer_agreed_to_wait=True,
        )

        db.session.add(backorder)
        db.session.flush()

        db.session.add(
            BackorderItem(
                backorder_id=backorder.id,
                order_item_id=order_item.id,
                variant_id=variant.id,
                quantity_requested=quantity,
                quantity_allocated=0,
                quoted_unit_price=unit_price,
            )
        )

        # ----------------------------------------------------
        # CREATE DELIVERY
        # ----------------------------------------------------

        db.session.add(
            Delivery(
                order_id=order.id,
                delivery_method=delivery_method,
                delivery_status="pending",
                address=(
                    delivery_address if delivery_method == "delivery" else None
                ),
                fee=delivery_fee,
            )
        )

        # ----------------------------------------------------
        # CREATE PAYMENT
        # ----------------------------------------------------

        payment = Payment(
            order_id=order.id,
            payment_method="mopay",
            amount=total,
            status="pending",
        )

        db.session.add(payment)
        db.session.flush()

        # ----------------------------------------------------
        # CREATE MOPAY REFERENCE AND INITIAL TRANSACTION
        # ----------------------------------------------------

        mopay_reference = (
            "GV" + uuid.uuid4().hex.upper()
        )

        transaction = record_backorder_payment_transaction(
            payment=payment,
            reference=mopay_reference,
        )

        # ----------------------------------------------------
        # ORDER AND BACKORDER HISTORY
        # ----------------------------------------------------

        db.session.add(
            OrderStatusHistory(
                order_id=order.id,
                status="pending",
                changed_by=None,
                note=(
                    "Backorder submitted. "
                    "Awaiting immediate MoPay payment."
                ),
            )
        )

        db.session.add(
            BackorderHistory(
                backorder_id=backorder.id,
                status="awaiting_stock",
                changed_by="customer",
                note=(
                    "Customer submitted a backorder request "
                    "and agreed to wait."
                ),
            )
        )

        # ----------------------------------------------------
        # SAVE RECORDS BEFORE CONTACTING MOPAY
        # ----------------------------------------------------

        db.session.commit()

        # Preserve IDs before the external request.
        order_id = order.id
        payment_id = payment.id
        transaction_id = transaction.id

    except (InvalidOperation, ValueError) as error:

        db.session.rollback()

        flash(str(error), "error")

        return redirect(
            request.referrer or url_for("home.index")
        )

    except Exception:

        db.session.rollback()

        flash(
            "We could not submit your backorder. Please try again.",
            "error",
        )

        return redirect(
            request.referrer or url_for("home.index")
        )

    # ========================================================
    # CREATE MOPAY PAYMENT SESSION
    # ========================================================

    try:

        mopay_response = create_payment_session(
            amount=total,
            reference=mopay_reference,
            redirect_url=MOPAY_REDIRECT_URL,
            description=f"Green Verges backorder {order_number}",
            customer_name=customer_name,
            customer_email=customer_email,
        )

        payment = db.session.get(
            Payment,
            payment_id,
        )

        transaction = db.session.get(
            PaymentTransaction,
            transaction_id,
        )

        if not payment or not transaction:
            raise RuntimeError(
                "The payment records could not be reloaded."
            )

        payment.gateway_reference = mopay_response["session_id"]

        transaction.status = "created"

        transaction.response_data = json.dumps(
            mopay_response
        )

        db.session.commit()

        session["pending_order_number"] = order_number

        return redirect(
            mopay_response["payment_url"]
        )

    except MoPayConfigurationError:

        db.session.rollback()

        payment = db.session.get(
            Payment,
            payment_id,
        )

        order = db.session.get(
            Order,
            order_id,
        )

        transaction = db.session.get(
            PaymentTransaction,
            transaction_id,
        )

        if payment and order:
            payment.status = "failed"
            order.payment_status = "failed"

        if transaction:
            transaction.status = "configuration_error"

        db.session.commit()

        flash(
            "MoPay is not configured correctly. "
            "Please contact the website administrator.",
            "error",
        )

        return redirect(
            url_for("home.index")
        )

    except MoPayError:

        db.session.rollback()

        # The gateway may have created a session even if the
        # response was not received. Keep records for verification.

        session["pending_order_number"] = order_number

        flash(
            "We could not confirm whether MoPay created your "
            "payment session. Your backorder has been saved "
            "for verification. Please contact us with order "
            f"number {order_number}.",
            "warning",
        )

        return redirect(
            url_for(
                "checkout.order_confirmation",
                order_number=order_number,
            )
        )

    except Exception:

        db.session.rollback()

        # Do not assume the remote session was not created.
        # Keep the order and payment records for reconciliation.

        session["pending_order_number"] = order_number

        flash(
            "Your payment session could not be confirmed. "
            "Your backorder has been saved for verification. "
            "Please contact us with order number "
            f"{order_number}.",
            "warning",
        )

        return redirect(
            url_for(
                "checkout.order_confirmation",
                order_number=order_number,
            )
        )


# ============================================================
# BACKORDER MOPAY PAYMENT RETURN
# ============================================================

@backorders_bp.route("/backorders/payment-complete")
def backorder_payment_complete():

    mopay_reference = request.args.get(
        "reference", ""
    ).strip()

    session_id = request.args.get(
        "sessionId", ""
    ).strip()

    if not mopay_reference or not session_id:
        flash(
            "We could not identify your payment. "
            "Please contact us if you completed payment.",
            "error",
        )

        return redirect(url_for("product.products"))

    transaction, payment, order, backorder = (
        get_backorder_payment_records(mopay_reference)
    )

    if not transaction or not payment or not order or not backorder:
        flash(
            "The backorder payment reference could not be found.",
            "error",
        )

        return redirect(url_for("product.products"))

    # --------------------------------------------------------
    # VERIFY PAYMENT WITH MOPAY
    # --------------------------------------------------------

    try:

        verified_session = verify_payment_session(
            session_id
        )

    except (MoPayError, ValueError):

        flash(
            "We could not verify your payment yet. "
            "Please try again shortly.",
            "error",
        )

        return order_confirmation_redirect(order)

    # --------------------------------------------------------
    # VERIFY SESSION ID
    # --------------------------------------------------------

    if (
        verified_session.get("sessionId")
        != payment.gateway_reference
    ):

        flash(
            "Payment session verification failed.",
            "error",
        )

        return redirect(url_for("product.products"))

    # --------------------------------------------------------
    # VERIFY REFERENCE
    # --------------------------------------------------------

    if (
        verified_session.get("reference")
        != mopay_reference
    ):

        flash(
            "Payment reference verification failed.",
            "error",
        )

        return redirect(url_for("product.products"))

    # --------------------------------------------------------
    # VERIFY AMOUNT
    # --------------------------------------------------------

    try:

        verified_amount = Decimal(
            str(verified_session.get("amount"))
        ).quantize(
            Decimal("0.01")
        )

        expected_amount = Decimal(
            str(payment.amount)
        ).quantize(
            Decimal("0.01")
        )

    except (InvalidOperation, TypeError, ValueError):

        flash(
            "The verified payment amount is invalid.",
            "error",
        )

        return redirect(url_for("product.products"))

    if verified_amount != expected_amount:

        flash(
            "Payment amount verification failed.",
            "error",
        )

        return redirect(url_for("product.products"))

    gateway_status = str(
        verified_session.get("status", "")
    ).upper()

    # ========================================================
    # LOCK PAYMENT, ORDER AND TRANSACTION
    # ========================================================

    try:

        payment = (
            Payment.query
            .filter_by(id=payment.id)
            .with_for_update()
            .populate_existing()
            .first()
        )

        if not payment:
            raise RuntimeError(
                "Payment record no longer exists."
            )

        order = (
            Order.query
            .filter_by(id=payment.order_id)
            .with_for_update()
            .populate_existing()
            .first()
        )

        if not order:
            raise RuntimeError(
                "Order record no longer exists."
            )

        transaction = (
            PaymentTransaction.query
            .filter_by(id=transaction.id)
            .with_for_update()
            .populate_existing()
            .first()
        )

        if not transaction:
            raise RuntimeError(
                "Payment transaction no longer exists."
            )

        backorder = (
            Backorder.query
            .filter_by(order_id=order.id)
            .with_for_update()
            .populate_existing()
            .first()
        )

        if not backorder:
            raise RuntimeError(
                "Backorder record no longer exists."
            )

        # ----------------------------------------------------
        # IDEMPOTENCY
        # ----------------------------------------------------

        if payment.status == "paid":

            db.session.rollback()

            return order_confirmation_redirect(order)

        # ----------------------------------------------------
        # PROCESSING
        # ----------------------------------------------------

        if gateway_status in ("CREATED", "PROCESSING"):

            transaction.status = "processing"

            transaction.response_data = json.dumps(
                verified_session
            )

            db.session.commit()

            flash(
                "Your payment is still processing. "
                "Please check again shortly.",
                "info",
            )

            return order_confirmation_redirect(order)

        # ----------------------------------------------------
        # FAILED, CANCELLED OR EXPIRED
        # ----------------------------------------------------

        if gateway_status in (
            "FAILED",
            "CANCELLED",
            "EXPIRED",
        ):

            payment.status = gateway_status.lower()

            order.payment_status = gateway_status.lower()

            transaction.status = gateway_status.lower()

            transaction.response_data = json.dumps(
                verified_session
            )

            db.session.commit()

            flash(
                "Your payment was not completed. "
                "Your backorder request has been saved, "
                "but payment is still outstanding.",
                "error",
            )

            return order_confirmation_redirect(order)

        # ----------------------------------------------------
        # UNKNOWN STATUS
        # ----------------------------------------------------

        if gateway_status != "COMPLETED":

            transaction.status = "unknown"

            transaction.response_data = json.dumps(
                verified_session
            )

            db.session.commit()

            flash(
                "Your payment status is not yet confirmed.",
                "warning",
            )

            return order_confirmation_redirect(order)

        # ====================================================
        # PAYMENT COMPLETED
        # ====================================================

        now = datetime.utcnow()

        payment.status = "paid"

        payment.transaction_reference = (
            verified_session.get("transactionId")
        )

        payment.paid_at = now

        order.payment_status = "paid"
        order.order_status = "paid"

        transaction.status = "completed"

        transaction.response_data = json.dumps(
            verified_session
        )

        # IMPORTANT:
        # Backorders have no stock reservations.
        # Payment does not deduct stock.
        # The backorder remains awaiting_stock until stock
        # replenishment is handled through the admin workflow.

        db.session.add(
            OrderStatusHistory(
                order_id=order.id,
                status="paid",
                changed_by=None,
                note=(
                    "MoPay payment for backorder verified "
                    "successfully. Backorder remains awaiting "
                    "stock replenishment."
                ),
            )
        )

        db.session.commit()

        return order_confirmation_redirect(order)

    except Exception:

        db.session.rollback()

        flash(
            "We received a payment return, but could not "
            "complete the backorder update. Please contact us "
            "with your order number.",
            "error",
        )

        return redirect(url_for("product.products"))


# ============================================================
# TRACK BACKORDER
# ============================================================

@backorders_bp.route("/backorders/track", methods=["GET", "POST"])
def track_backorder():

    order = None
    backorder = None
    searched = False

    if request.method == "POST":

        order_number = request.form.get(
            "order_number", ""
        ).strip().upper()

        customer_phone = request.form.get(
            "customer_phone", ""
        ).strip()

        searched = True

        if order_number and customer_phone:

            order = Order.query.filter_by(
                order_number=order_number,
                customer_phone=customer_phone,
                order_source="backorder",
            ).first()

            if order:
                backorder = Backorder.query.filter_by(
                    order_id=order.id,
                ).first()

        if not order or not backorder:

            order = None
            backorder = None

            flash(
                "We could not find a backorder matching those details.",
                "error",
            )

    return render_template(
        "backorders/track_backorder.html",
        order=order,
        backorder=backorder,
        searched=searched,
    )


# ============================================================
# ADMIN BACKORDER MANAGEMENT
# ============================================================

@backorders_bp.route("/admin/backorders", methods=["GET"])
@admin_required
def admin_backorders():

    status = request.args.get(
        "status", "all"
    ).strip().lower()

    query = (
        Backorder.query
        .join(Order, Backorder.order_id == Order.id)
    )

    if status != "all":
        query = query.filter(
            Backorder.status == status
        )

    backorders = (
        query
        .order_by(Backorder.created_at.desc())
        .all()
    )

    counts = {
        "all": Backorder.query.count(),

        "awaiting_stock": Backorder.query.filter_by(
            status="awaiting_stock"
        ).count(),

        "stock_ordered": Backorder.query.filter_by(
            status="stock_ordered"
        ).count(),

        "stock_received": Backorder.query.filter_by(
            status="stock_received"
        ).count(),

        "cancelled": Backorder.query.filter_by(
            status="cancelled"
        ).count(),
    }

    return render_template(
        "admin/backorders.html",
        backorders=backorders,
        selected_status=status,
        counts=counts,
    )


# ============================================================
# UPDATE BACKORDER STATUS
# ============================================================

@backorders_bp.route(
    "/admin/backorders/<int:backorder_id>/status",
    methods=["POST"],
)
@admin_required
def update_backorder_status(backorder_id):

    backorder = db.session.get(
        Backorder,
        backorder_id,
    )

    if not backorder:
        flash("Backorder not found.", "error")
        return redirect(url_for("backorders.admin_backorders"))

    new_status = request.form.get(
        "status", ""
    ).strip().lower()

    note = request.form.get(
        "note", ""
    ).strip()

    if new_status not in ADMIN_BACKORDER_STATUSES:
        flash("Invalid backorder status.", "error")
        return redirect(url_for("backorders.admin_backorders"))

    if backorder.status in ("paid", "cancelled"):
        flash("This backorder can no longer be updated.", "error")
        return redirect(url_for("backorders.admin_backorders"))

    allowed_transitions = {
        "awaiting_stock": {"stock_ordered", "cancelled"},
        "stock_ordered": {"stock_received", "cancelled"},
        "stock_received": {"cancelled"},
    }

    if new_status not in allowed_transitions.get(
        backorder.status, set()
    ):
        flash("That status change is not allowed.", "error")
        return redirect(url_for("backorders.admin_backorders"))

    try:

        previous_status = backorder.status
        backorder.status = new_status

        if new_status == "stock_ordered":
            backorder.stock_ordered_at = datetime.utcnow()

        elif new_status == "stock_received":
            backorder.stock_received_at = datetime.utcnow()

        order = backorder.order

        db.session.add(
            BackorderHistory(
                backorder_id=backorder.id,
                status=new_status,
                changed_by=(
                    request.form.get("changed_by", "").strip()
                    or "admin"
                ),
                note=note or (
                    f"Backorder status changed from "
                    f"{previous_status.replace('_', ' ')} to "
                    f"{new_status.replace('_', ' ')}."
                ),
            )
        )

        if order:
            db.session.add(
                OrderStatusHistory(
                    order_id=order.id,
                    status=order.order_status,
                    changed_by=(
                        request.form.get("changed_by", "").strip()
                        or "admin"
                    ),
                    note=(
                        f"Backorder update: "
                        f"{new_status.replace('_', ' ')}."
                    ),
                )
            )

        db.session.commit()

        flash(
            "Backorder status updated successfully.",
            "success",
        )

    except Exception:

        db.session.rollback()

        flash(
            "Could not update the backorder.",
            "error",
        )

    return redirect(
        url_for(
            "backorders.admin_backorders",
            status=request.args.get("filter", "all"),
        )
    )
