From adbcee4ce3cb4665aba561fc9576be8333fe0b9a Mon Sep 17 00:00:00 2001
From: Samir Boulahtit <samir.boulahtit@wizard.lu>
Date: Sun, 9 Nov 2025 18:47:53 +0100
Subject: [PATCH] middleware fix for path-based vendor url

---
 .env                                     |    2 +-
 Makefile                                 |   27 +-
 app/exceptions/error_renderer.py         |    2 +-
 app/routes/shop_pages.py                 |  486 ++++++--
 create_project_structure.bat             |  355 ------
 docs/development/synology-github-repo.md |    2 +-
 main.py                                  |  124 +-
 middleware/context_middleware.py         |  101 +-
 middleware/path_rewrite_middleware.py    |   63 +
 middleware/theme_context.py              |   92 +-
 middleware/vendor_context.py             |  197 +--
 models/database/vendor.py                |    1 -
 scripts/seed_database.py                 | 1436 +++++++++++++++++++---
 13 files changed, 2078 insertions(+), 810 deletions(-)
 delete mode 100644 create_project_structure.bat
 create mode 100644 middleware/path_rewrite_middleware.py

diff --git a/.env b/.env
index 4b92403e..01271fbb 100644
--- a/.env
+++ b/.env
@@ -34,7 +34,7 @@ RATE_LIMIT_REQUESTS=100
 RATE_LIMIT_WINDOW=3600
 
 # Logging
-LOG_LEVEL=INFO
+LOG_LEVEL=DEBUG
 LOG_FILE=log/app.log
 
 # Platform domain configuration
diff --git a/Makefile b/Makefile
index 76b4c629..21ab040f 100644
--- a/Makefile
+++ b/Makefile
@@ -77,6 +77,31 @@ backup-db:
 	@echo Creating database backup...
 	@$(PYTHON) scripts/backup_database.py
 
+# Add these commands to the DATABASE section after backup-db:
+
+seed:
+	@echo Seeding database with comprehensive test data...
+	$(PYTHON) scripts/seed_database.py
+	@echo Seeding completed successfully
+
+seed-minimal:
+	@echo Seeding database with minimal data (admin + 1 vendor)...
+	$(PYTHON) scripts/seed_database.py --minimal
+	@echo Minimal seeding completed
+
+seed-reset:
+	@echo WARNING: This will DELETE ALL existing data!
+	$(PYTHON) scripts/seed_database.py --reset
+	@echo Database reset and seeded
+
+# Complete database setup (migrate + seed)
+db-setup: migrate-up seed
+	@echo Database setup complete!
+	@echo Run 'make dev' to start development server
+
+db-reset: migrate-down migrate-up seed-reset
+	@echo Database completely reset!
+
 # =============================================================================
 # TESTING
 # =============================================================================
@@ -295,4 +320,4 @@ help-db:
 	@echo   1. Edit your SQLAlchemy models
 	@echo   2. make migrate-create message="add_new_feature"
 	@echo   3. Review the generated migration file
-	@echo   4. make migrate-up
\ No newline at end of file
+	@echo   4. make migrate-up
diff --git a/app/exceptions/error_renderer.py b/app/exceptions/error_renderer.py
index 74608742..27874ad5 100644
--- a/app/exceptions/error_renderer.py
+++ b/app/exceptions/error_renderer.py
@@ -344,4 +344,4 @@ class ErrorPageRenderer:
 </body>
 </html>
         """
-        return HTMLResponse(content=html_content, status_code=status_code)
\ No newline at end of file
+        return HTMLResponse(content=html_content, status_code=status_code)
diff --git a/app/routes/shop_pages.py b/app/routes/shop_pages.py
index 5a300860..bed982ee 100644
--- a/app/routes/shop_pages.py
+++ b/app/routes/shop_pages.py
@@ -29,6 +29,7 @@ Routes:
 - GET /shop/account/addresses     → Address management (auth required)
 """
 
+import logging
 from fastapi import APIRouter, Request, Depends, Path
 from fastapi.responses import HTMLResponse, RedirectResponse
 from fastapi.templating import Jinja2Templates
@@ -40,59 +41,144 @@ from models.database.user import User
 router = APIRouter()
 templates = Jinja2Templates(directory="app/templates")
 
+logger = logging.getLogger(__name__)
+
+
+# ============================================================================
+# HELPER: Build Shop Template Context
+# ============================================================================
+
+def get_shop_context(request: Request, **extra_context) -> dict:
+    """
+    Build template context for shop pages.
+
+    Automatically includes vendor and theme from middleware request.state.
+    Additional context can be passed as keyword arguments.
+
+    Args:
+        request: FastAPI request object with vendor/theme in state
+        **extra_context: Additional variables for template (user, product_id, etc.)
+
+    Returns:
+        Dictionary with request, vendor, theme, and extra context
+
+    Example:
+        # Simple usage
+        get_shop_context(request)
+
+        # With extra data
+        get_shop_context(request, user=current_user, product_id=123)
+    """
+    # Extract from middleware state
+    vendor = getattr(request.state, 'vendor', None)
+    theme = getattr(request.state, 'theme', None)
+    clean_path = getattr(request.state, 'clean_path', request.url.path)
+
+    if vendor is None:
+        logger.warning(
+            "[SHOP_CONTEXT] Vendor not found in request.state",
+            extra={
+                "path": request.url.path,
+                "host": request.headers.get("host", ""),
+                "has_vendor": False,
+            }
+        )
+
+    context = {
+        "request": request,
+        "vendor": vendor,
+        "theme": theme,
+        "clean_path": clean_path,
+    }
+
+    # Add any extra context (user, product_id, category_slug, etc.)
+    if extra_context:
+        context.update(extra_context)
+
+    logger.debug(
+        f"[SHOP_CONTEXT] Context built",
+        extra={
+            "vendor_id": vendor.id if vendor else None,
+            "vendor_name": vendor.name if vendor else None,
+            "has_theme": theme is not None,
+            "extra_keys": list(extra_context.keys()) if extra_context else [],
+        }
+    )
+
+    return context
+
 
 # ============================================================================
 # PUBLIC SHOP ROUTES (No Authentication Required)
 # ============================================================================
 
-@router.get("/shop/", response_class=HTMLResponse, include_in_schema=False)
-@router.get("/shop/products", response_class=HTMLResponse, include_in_schema=False)
+@router.get("/", response_class=HTMLResponse, include_in_schema=False)
+@router.get("/products", response_class=HTMLResponse, include_in_schema=False)
 async def shop_products_page(request: Request):
     """
     Render shop homepage / product catalog.
     Shows featured products and categories.
     """
+    logger.debug(
+        f"[SHOP_HANDLER] shop_products_page REACHED",
+        extra={
+            "path": request.url.path,
+            "vendor": getattr(request.state, 'vendor', 'NOT SET'),
+            "context": getattr(request.state, 'context_type', 'NOT SET'),
+        }
+    )
+
     return templates.TemplateResponse(
         "shop/products.html",
-        {
-            "request": request,
-        }
+        get_shop_context(request)
     )
 
 
 @router.get("/shop/products/{product_id}", response_class=HTMLResponse, include_in_schema=False)
 async def shop_product_detail_page(
-    request: Request,
-    product_id: int = Path(..., description="Product ID")
+        request: Request,
+        product_id: int = Path(..., description="Product ID")
 ):
     """
     Render product detail page.
     Shows product information, images, reviews, and buy options.
     """
+    logger.debug(
+        f"[SHOP_HANDLER] shop_products_page REACHED",
+        extra={
+            "path": request.url.path,
+            "vendor": getattr(request.state, 'vendor', 'NOT SET'),
+            "context": getattr(request.state, 'context_type', 'NOT SET'),
+        }
+    )
+
     return templates.TemplateResponse(
         "shop/product.html",
-        {
-            "request": request,
-            "product_id": product_id,
-        }
+        get_shop_context(request, product_id=product_id)
     )
 
 
 @router.get("/shop/categories/{category_slug}", response_class=HTMLResponse, include_in_schema=False)
 async def shop_category_page(
-    request: Request,
-    category_slug: str = Path(..., description="Category slug")
+        request: Request,
+        category_slug: str = Path(..., description="Category slug")
 ):
     """
     Render category products page.
     Shows all products in a specific category.
     """
+    logger.debug(
+        f"[SHOP_HANDLER] shop_products_page REACHED",
+        extra={
+            "path": request.url.path,
+            "vendor": getattr(request.state, 'vendor', 'NOT SET'),
+            "context": getattr(request.state, 'context_type', 'NOT SET'),
+        }
+    )
+
     return templates.TemplateResponse(
         "shop/category.html",
-        {
-            "request": request,
-            "category_slug": category_slug,
-        }
+        get_shop_context(request, category_slug=category_slug)
     )
 
 
@@ -102,11 +188,18 @@ async def shop_cart_page(request: Request):
     Render shopping cart page.
     Shows cart items and allows quantity updates.
     """
+    logger.debug(
+        f"[SHOP_HANDLER] shop_products_page REACHED",
+        extra={
+            "path": request.url.path,
+            "vendor": getattr(request.state, 'vendor', 'NOT SET'),
+            "context": getattr(request.state, 'context_type', 'NOT SET'),
+        }
+    )
+
     return templates.TemplateResponse(
         "shop/cart.html",
-        {
-            "request": request,
-        }
+        get_shop_context(request)
     )
 
 
@@ -116,11 +209,18 @@ async def shop_checkout_page(request: Request):
     Render checkout page.
     Handles shipping, payment, and order confirmation.
     """
+    logger.debug(
+        f"[SHOP_HANDLER] shop_products_page REACHED",
+        extra={
+            "path": request.url.path,
+            "vendor": getattr(request.state, 'vendor', 'NOT SET'),
+            "context": getattr(request.state, 'context_type', 'NOT SET'),
+        }
+    )
+
     return templates.TemplateResponse(
         "shop/checkout.html",
-        {
-            "request": request,
-        }
+        get_shop_context(request)
     )
 
 
@@ -130,11 +230,18 @@ async def shop_search_page(request: Request):
     Render search results page.
     Shows products matching search query.
     """
+    logger.debug(
+        f"[SHOP_HANDLER] shop_products_page REACHED",
+        extra={
+            "path": request.url.path,
+            "vendor": getattr(request.state, 'vendor', 'NOT SET'),
+            "context": getattr(request.state, 'context_type', 'NOT SET'),
+        }
+    )
+
     return templates.TemplateResponse(
         "shop/search.html",
-        {
-            "request": request,
-        }
+        get_shop_context(request)
     )
 
 
@@ -148,11 +255,18 @@ async def shop_register_page(request: Request):
     Render customer registration page.
     No authentication required.
     """
+    logger.debug(
+        f"[SHOP_HANDLER] shop_products_page REACHED",
+        extra={
+            "path": request.url.path,
+            "vendor": getattr(request.state, 'vendor', 'NOT SET'),
+            "context": getattr(request.state, 'context_type', 'NOT SET'),
+        }
+    )
+
     return templates.TemplateResponse(
         "shop/account/register.html",
-        {
-            "request": request,
-        }
+        get_shop_context(request)
     )
 
 
@@ -162,11 +276,18 @@ async def shop_login_page(request: Request):
     Render customer login page.
     No authentication required.
     """
+    logger.debug(
+        f"[SHOP_HANDLER] shop_products_page REACHED",
+        extra={
+            "path": request.url.path,
+            "vendor": getattr(request.state, 'vendor', 'NOT SET'),
+            "context": getattr(request.state, 'context_type', 'NOT SET'),
+        }
+    )
+
     return templates.TemplateResponse(
         "shop/account/login.html",
-        {
-            "request": request,
-        }
+        get_shop_context(request)
     )
 
 
@@ -176,11 +297,18 @@ async def shop_forgot_password_page(request: Request):
     Render forgot password page.
     Allows customers to reset their password.
     """
+    logger.debug(
+        f"[SHOP_HANDLER] shop_products_page REACHED",
+        extra={
+            "path": request.url.path,
+            "vendor": getattr(request.state, 'vendor', 'NOT SET'),
+            "context": getattr(request.state, 'context_type', 'NOT SET'),
+        }
+    )
+
     return templates.TemplateResponse(
         "shop/account/forgot-password.html",
-        {
-            "request": request,
-        }
+        get_shop_context(request)
     )
 
 
@@ -193,148 +321,198 @@ async def shop_account_root():
     """
     Redirect /shop/account/ to dashboard.
     """
+    logger.debug(
+        f"[SHOP_HANDLER] shop_products_page REACHED",
+        extra={
+            "path": request.url.path,
+            "vendor": getattr(request.state, 'vendor', 'NOT SET'),
+            "context": getattr(request.state, 'context_type', 'NOT SET'),
+        }
+    )
+
     return RedirectResponse(url="/shop/account/dashboard", status_code=302)
 
 
 @router.get("/shop/account/dashboard", response_class=HTMLResponse, include_in_schema=False)
 async def shop_account_dashboard_page(
-    request: Request,
-    current_user: User = Depends(get_current_customer_from_cookie_or_header),
-    db: Session = Depends(get_db)
+        request: Request,
+        current_user: User = Depends(get_current_customer_from_cookie_or_header),
+        db: Session = Depends(get_db)
 ):
     """
     Render customer account dashboard.
     Shows account overview, recent orders, and quick links.
     Requires customer authentication.
     """
+    logger.debug(
+        f"[SHOP_HANDLER] shop_products_page REACHED",
+        extra={
+            "path": request.url.path,
+            "vendor": getattr(request.state, 'vendor', 'NOT SET'),
+            "context": getattr(request.state, 'context_type', 'NOT SET'),
+        }
+    )
+
     return templates.TemplateResponse(
         "shop/account/dashboard.html",
-        {
-            "request": request,
-            "user": current_user,
-        }
+        get_shop_context(request, user=current_user)
     )
 
 
 @router.get("/shop/account/orders", response_class=HTMLResponse, include_in_schema=False)
 async def shop_orders_page(
-    request: Request,
-    current_user: User = Depends(get_current_customer_from_cookie_or_header),
-    db: Session = Depends(get_db)
+        request: Request,
+        current_user: User = Depends(get_current_customer_from_cookie_or_header),
+        db: Session = Depends(get_db)
 ):
     """
     Render customer orders history page.
     Shows all past and current orders.
     Requires customer authentication.
     """
+    logger.debug(
+        f"[SHOP_HANDLER] shop_products_page REACHED",
+        extra={
+            "path": request.url.path,
+            "vendor": getattr(request.state, 'vendor', 'NOT SET'),
+            "context": getattr(request.state, 'context_type', 'NOT SET'),
+        }
+    )
+
     return templates.TemplateResponse(
         "shop/account/orders.html",
-        {
-            "request": request,
-            "user": current_user,
-        }
+        get_shop_context(request, user=current_user)
     )
 
 
 @router.get("/shop/account/orders/{order_id}", response_class=HTMLResponse, include_in_schema=False)
 async def shop_order_detail_page(
-    request: Request,
-    order_id: int = Path(..., description="Order ID"),
-    current_user: User = Depends(get_current_customer_from_cookie_or_header),
-    db: Session = Depends(get_db)
+        request: Request,
+        order_id: int = Path(..., description="Order ID"),
+        current_user: User = Depends(get_current_customer_from_cookie_or_header),
+        db: Session = Depends(get_db)
 ):
     """
     Render customer order detail page.
     Shows detailed order information and tracking.
     Requires customer authentication.
     """
+    logger.debug(
+        f"[SHOP_HANDLER] shop_products_page REACHED",
+        extra={
+            "path": request.url.path,
+            "vendor": getattr(request.state, 'vendor', 'NOT SET'),
+            "context": getattr(request.state, 'context_type', 'NOT SET'),
+        }
+    )
+
     return templates.TemplateResponse(
         "shop/account/order-detail.html",
-        {
-            "request": request,
-            "user": current_user,
-            "order_id": order_id,
-        }
+        get_shop_context(request, user=current_user, order_id=order_id)
     )
 
 
 @router.get("/shop/account/profile", response_class=HTMLResponse, include_in_schema=False)
 async def shop_profile_page(
-    request: Request,
-    current_user: User = Depends(get_current_customer_from_cookie_or_header),
-    db: Session = Depends(get_db)
+        request: Request,
+        current_user: User = Depends(get_current_customer_from_cookie_or_header),
+        db: Session = Depends(get_db)
 ):
     """
     Render customer profile page.
     Edit personal information and preferences.
     Requires customer authentication.
     """
+    logger.debug(
+        f"[SHOP_HANDLER] shop_products_page REACHED",
+        extra={
+            "path": request.url.path,
+            "vendor": getattr(request.state, 'vendor', 'NOT SET'),
+            "context": getattr(request.state, 'context_type', 'NOT SET'),
+        }
+    )
+
     return templates.TemplateResponse(
         "shop/account/profile.html",
-        {
-            "request": request,
-            "user": current_user,
-        }
+        get_shop_context(request, user=current_user)
     )
 
 
 @router.get("/shop/account/addresses", response_class=HTMLResponse, include_in_schema=False)
 async def shop_addresses_page(
-    request: Request,
-    current_user: User = Depends(get_current_customer_from_cookie_or_header),
-    db: Session = Depends(get_db)
+        request: Request,
+        current_user: User = Depends(get_current_customer_from_cookie_or_header),
+        db: Session = Depends(get_db)
 ):
     """
     Render customer addresses management page.
     Manage shipping and billing addresses.
     Requires customer authentication.
     """
+    logger.debug(
+        f"[SHOP_HANDLER] shop_products_page REACHED",
+        extra={
+            "path": request.url.path,
+            "vendor": getattr(request.state, 'vendor', 'NOT SET'),
+            "context": getattr(request.state, 'context_type', 'NOT SET'),
+        }
+    )
+
     return templates.TemplateResponse(
         "shop/account/addresses.html",
-        {
-            "request": request,
-            "user": current_user,
-        }
+        get_shop_context(request, user=current_user)
     )
 
 
 @router.get("/shop/account/wishlist", response_class=HTMLResponse, include_in_schema=False)
 async def shop_wishlist_page(
-    request: Request,
-    current_user: User = Depends(get_current_customer_from_cookie_or_header),
-    db: Session = Depends(get_db)
+        request: Request,
+        current_user: User = Depends(get_current_customer_from_cookie_or_header),
+        db: Session = Depends(get_db)
 ):
     """
     Render customer wishlist page.
     View and manage saved products.
     Requires customer authentication.
     """
+    logger.debug(
+        f"[SHOP_HANDLER] shop_products_page REACHED",
+        extra={
+            "path": request.url.path,
+            "vendor": getattr(request.state, 'vendor', 'NOT SET'),
+            "context": getattr(request.state, 'context_type', 'NOT SET'),
+        }
+    )
+
     return templates.TemplateResponse(
         "shop/account/wishlist.html",
-        {
-            "request": request,
-            "user": current_user,
-        }
+        get_shop_context(request, user=current_user)
     )
 
 
 @router.get("/shop/account/settings", response_class=HTMLResponse, include_in_schema=False)
 async def shop_settings_page(
-    request: Request,
-    current_user: User = Depends(get_current_customer_from_cookie_or_header),
-    db: Session = Depends(get_db)
+        request: Request,
+        current_user: User = Depends(get_current_customer_from_cookie_or_header),
+        db: Session = Depends(get_db)
 ):
     """
     Render customer account settings page.
     Configure notifications, privacy, and preferences.
     Requires customer authentication.
     """
+    logger.debug(
+        f"[SHOP_HANDLER] shop_products_page REACHED",
+        extra={
+            "path": request.url.path,
+            "vendor": getattr(request.state, 'vendor', 'NOT SET'),
+            "context": getattr(request.state, 'context_type', 'NOT SET'),
+        }
+    )
+
     return templates.TemplateResponse(
         "shop/account/settings.html",
-        {
-            "request": request,
-            "user": current_user,
-        }
+        get_shop_context(request, user=current_user)
     )
 
 
@@ -347,11 +525,18 @@ async def shop_about_page(request: Request):
     """
     Render about us page.
     """
+    logger.debug(
+        f"[SHOP_HANDLER] shop_products_page REACHED",
+        extra={
+            "path": request.url.path,
+            "vendor": getattr(request.state, 'vendor', 'NOT SET'),
+            "context": getattr(request.state, 'context_type', 'NOT SET'),
+        }
+    )
+
     return templates.TemplateResponse(
         "shop/about.html",
-        {
-            "request": request,
-        }
+        get_shop_context(request)
     )
 
 
@@ -360,11 +545,18 @@ async def shop_contact_page(request: Request):
     """
     Render contact us page.
     """
+    logger.debug(
+        f"[SHOP_HANDLER] shop_products_page REACHED",
+        extra={
+            "path": request.url.path,
+            "vendor": getattr(request.state, 'vendor', 'NOT SET'),
+            "context": getattr(request.state, 'context_type', 'NOT SET'),
+        }
+    )
+
     return templates.TemplateResponse(
         "shop/contact.html",
-        {
-            "request": request,
-        }
+        get_shop_context(request)
     )
 
 
@@ -373,11 +565,18 @@ async def shop_faq_page(request: Request):
     """
     Render FAQ page.
     """
+    logger.debug(
+        f"[SHOP_HANDLER] shop_products_page REACHED",
+        extra={
+            "path": request.url.path,
+            "vendor": getattr(request.state, 'vendor', 'NOT SET'),
+            "context": getattr(request.state, 'context_type', 'NOT SET'),
+        }
+    )
+
     return templates.TemplateResponse(
         "shop/faq.html",
-        {
-            "request": request,
-        }
+        get_shop_context(request)
     )
 
 
@@ -386,11 +585,18 @@ async def shop_privacy_page(request: Request):
     """
     Render privacy policy page.
     """
+    logger.debug(
+        f"[SHOP_HANDLER] shop_products_page REACHED",
+        extra={
+            "path": request.url.path,
+            "vendor": getattr(request.state, 'vendor', 'NOT SET'),
+            "context": getattr(request.state, 'context_type', 'NOT SET'),
+        }
+    )
+
     return templates.TemplateResponse(
         "shop/privacy.html",
-        {
-            "request": request,
-        }
+        get_shop_context(request)
     )
 
 
@@ -399,9 +605,85 @@ async def shop_terms_page(request: Request):
     """
     Render terms and conditions page.
     """
-    return templates.TemplateResponse(
-        "shop/terms.html",
-        {
-            "request": request,
+    logger.debug(
+        f"[SHOP_HANDLER] shop_products_page REACHED",
+        extra={
+            "path": request.url.path,
+            "vendor": getattr(request.state, 'vendor', 'NOT SET'),
+            "context": getattr(request.state, 'context_type', 'NOT SET'),
         }
     )
+
+    return templates.TemplateResponse(
+        "shop/terms.html",
+        get_shop_context(request)
+    )
+
+
+# ============================================================================
+# DEBUG ENDPOINTS - For troubleshooting context issues
+# ============================================================================
+
+@router.get("/debug/context", response_class=HTMLResponse, include_in_schema=False)
+async def debug_context(request: Request):
+    """
+    DEBUG ENDPOINT: Display request context.
+
+    Shows what's available in request.state.
+    Useful for troubleshooting template variable issues.
+
+    URL: /shop/debug/context
+    """
+    vendor = getattr(request.state, 'vendor', None)
+    theme = getattr(request.state, 'theme', None)
+
+    debug_info = {
+        "path": request.url.path,
+        "host": request.headers.get("host", ""),
+        "vendor": {
+            "found": vendor is not None,
+            "id": vendor.id if vendor else None,
+            "name": vendor.name if vendor else None,
+            "subdomain": vendor.subdomain if vendor else None,
+            "is_active": vendor.is_active if vendor else None,
+        },
+        "theme": {
+            "found": theme is not None,
+            "name": theme.get("theme_name") if theme else None,
+        },
+        "clean_path": getattr(request.state, 'clean_path', 'NOT SET'),
+        "context_type": str(getattr(request.state, 'context_type', 'NOT SET')),
+    }
+
+    # Return as JSON-like HTML for easy reading
+    import json
+    html_content = f"""
+    <!DOCTYPE html>
+    <html>
+    <head>
+        <title>Debug Context</title>
+        <style>
+            body {{ font-family: monospace; margin: 20px; }}
+            pre {{ background: #f0f0f0; padding: 20px; border-radius: 5px; }}
+            .good {{ color: green; }}
+            .bad {{ color: red; }}
+        </style>
+    </head>
+    <body>
+        <h1>Request Context Debug</h1>
+        <pre>{json.dumps(debug_info, indent=2)}</pre>
+
+        <h2>Status</h2>
+        <p class="{'good' if vendor else 'bad'}">
+            Vendor: {'✓ Found' if vendor else '✗ Not Found'}
+        </p>
+        <p class="{'good' if theme else 'bad'}">
+            Theme: {'✓ Found' if theme else '✗ Not Found'}
+        </p>
+        <p class="{'good' if str(getattr(request.state, 'context_type', 'NOT SET')) == 'shop' else 'bad'}">
+            Context Type: {str(getattr(request.state, 'context_type', 'NOT SET'))}
+        </p>
+    </body>
+    </html>
+    """
+    return HTMLResponse(content=html_content)
diff --git a/create_project_structure.bat b/create_project_structure.bat
deleted file mode 100644
index af48bbab..00000000
--- a/create_project_structure.bat
+++ /dev/null
@@ -1,355 +0,0 @@
-@echo off
-setlocal enabledelayedexpansion
-
-echo ========================================
-echo  FastAPI Project Structure Builder
-echo  (Safe Mode - Won't Override Existing Files)
-echo ========================================
-echo.
-
-:: Create root directories
-call :CreateDir "app"
-call :CreateDir "app\api"
-call :CreateDir "app\api\v1"
-call :CreateDir "app\api\v1\admin"
-call :CreateDir "app\api\v1\vendor"
-call :CreateDir "app\api\v1\public"
-call :CreateDir "app\api\v1\public\vendors"
-call :CreateDir "app\api\v1\shared"
-call :CreateDir "app\core"
-call :CreateDir "app\exceptions"
-call :CreateDir "app\services"
-
-call :CreateDir "tasks"
-
-call :CreateDir "models"
-call :CreateDir "models\database"
-call :CreateDir "models\schema"
-
-call :CreateDir "middleware"
-call :CreateDir "storage"
-
-call :CreateDir "static"
-call :CreateDir "static\admin"
-call :CreateDir "static\vendor"
-call :CreateDir "static\vendor\admin"
-call :CreateDir "static\vendor\admin\marketplace"
-call :CreateDir "static\shop"
-call :CreateDir "static\shop\account"
-call :CreateDir "static\css"
-call :CreateDir "static\css\admin"
-call :CreateDir "static\css\vendor"
-call :CreateDir "static\css\shop"
-call :CreateDir "static\css\shared"
-call :CreateDir "static\css\themes"
-call :CreateDir "static\js"
-call :CreateDir "static\js\shared"
-call :CreateDir "static\js\admin"
-call :CreateDir "static\js\vendor"
-call :CreateDir "static\js\shop"
-
-echo.
-echo Creating Python files...
-echo.
-
-:: Root files
-call :CreatePyFile "main.py" "FastAPI application entry point"
-
-:: API files
-call :CreatePyFile "app\api\deps.py" "Common dependencies"
-call :CreatePyFile "app\api\main.py" "API router setup"
-call :CreatePyFile "app\api\__init__.py" ""
-call :CreatePyFile "app\api\v1\__init__.py" ""
-
-:: Admin API files
-call :CreatePyFile "app\api\v1\admin\__init__.py" ""
-call :CreatePyFile "app\api\v1\admin\auth.py" "Admin authentication"
-call :CreatePyFile "app\api\v1\admin\vendors.py" "Vendor management - CRUD and bulk import"
-call :CreatePyFile "app\api\v1\admin\dashboard.py" "Admin dashboard and statistics"
-call :CreatePyFile "app\api\v1\admin\users.py" "User management across vendors"
-call :CreatePyFile "app\api\v1\admin\marketplace.py" "System-wide marketplace monitoring"
-call :CreatePyFile "app\api\v1\admin\monitoring.py" "Platform monitoring and alerts"
-
-:: Vendor API files
-call :CreatePyFile "app\api\v1\vendor\__init__.py" ""
-call :CreatePyFile "app\api\v1\vendor\auth.py" "Vendor team authentication"
-call :CreatePyFile "app\api\v1\vendor\dashboard.py" "Vendor dashboard and statistics"
-call :CreatePyFile "app\api\v1\vendor\products.py" "Vendor catalog management - Product table"
-call :CreatePyFile "app\api\v1\vendor\marketplace.py" "Marketplace import and selection - MarketplaceProduct table"
-call :CreatePyFile "app\api\v1\vendor\orders.py" "Vendor order management"
-call :CreatePyFile "app\api\v1\vendor\customers.py" "Vendor customer management"
-call :CreatePyFile "app\api\v1\vendor\teams.py" "Team member management"
-call :CreatePyFile "app\api\v1\vendor\inventory.py" "Inventory operations - vendor catalog products"
-call :CreatePyFile "app\api\v1\vendor\payments.py" "Payment configuration and processing"
-call :CreatePyFile "app\api\v1\vendor\media.py" "File and media management"
-call :CreatePyFile "app\api\v1\vendor\notifications.py" "Notification management"
-call :CreatePyFile "app\api\v1\vendor\settings.py" "Vendor settings and configuration"
-
-:: Public API files
-call :CreatePyFile "app\api\v1\public\__init__.py" ""
-call :CreatePyFile "app\api\v1\public\vendors\shop.py" "Public shop info"
-call :CreatePyFile "app\api\v1\public\vendors\products.py" "Public product catalog - Product table only"
-call :CreatePyFile "app\api\v1\public\vendors\search.py" "Product search functionality"
-call :CreatePyFile "app\api\v1\public\vendors\cart.py" "Shopping cart operations"
-call :CreatePyFile "app\api\v1\public\vendors\orders.py" "Order placement"
-call :CreatePyFile "app\api\v1\public\vendors\payments.py" "Payment processing"
-call :CreatePyFile "app\api\v1\public\vendors\auth.py" "Customer authentication"
-
-:: Shared API files
-call :CreatePyFile "app\api\v1\shared\health.py" "Health checks"
-call :CreatePyFile "app\api\v1\shared\webhooks.py" "External webhooks - Stripe, etc"
-call :CreatePyFile "app\api\v1\shared\uploads.py" "File upload handling"
-
-:: Core files
-call :CreatePyFile "app\core\__init__.py" ""
-call :CreatePyFile "app\core\config.py" "Configuration settings"
-call :CreatePyFile "app\core\database.py" "Database setup"
-call :CreatePyFile "app\core\lifespan.py" "App lifecycle management"
-
-:: Exception files
-call :CreatePyFile "app\exceptions\__init__.py" "All exception exports"
-call :CreatePyFile "app\exceptions\base.py" "Base exception classes"
-call :CreatePyFile "app\exceptions\handler.py" "Unified FastAPI exception handlers"
-call :CreatePyFile "app\exceptions\auth.py" "Authentication and authorization exceptions"
-call :CreatePyFile "app\exceptions\admin.py" "Admin operation exceptions"
-call :CreatePyFile "app\exceptions\marketplace.py" "Import and marketplace exceptions"
-call :CreatePyFile "app\exceptions\marketplace_product.py" "Marketplace staging exceptions"
-call :CreatePyFile "app\exceptions\product.py" "Vendor catalog exceptions"
-call :CreatePyFile "app\exceptions\vendor.py" "Vendor management exceptions"
-call :CreatePyFile "app\exceptions\customer.py" "Customer management exceptions"
-call :CreatePyFile "app\exceptions\order.py" "Order management exceptions"
-call :CreatePyFile "app\exceptions\payment.py" "Payment processing exceptions"
-call :CreatePyFile "app\exceptions\inventory.py" "Inventory management exceptions"
-call :CreatePyFile "app\exceptions\media.py" "Media and file management exceptions"
-call :CreatePyFile "app\exceptions\notification.py" "Notification exceptions"
-call :CreatePyFile "app\exceptions\search.py" "Search exceptions"
-call :CreatePyFile "app\exceptions\monitoring.py" "Monitoring exceptions"
-call :CreatePyFile "app\exceptions\backup.py" "Backup and recovery exceptions"
-
-:: Service files
-call :CreatePyFile "app\services\__init__.py" ""
-call :CreatePyFile "app\services\auth_service.py" "Authentication and authorization services"
-call :CreatePyFile "app\services\admin_service.py" "Admin services"
-call :CreatePyFile "app\services\vendor_service.py" "Vendor management services"
-call :CreatePyFile "app\services\customer_service.py" "Customer services - vendor-scoped"
-call :CreatePyFile "app\services\team_service.py" "Team management services"
-call :CreatePyFile "app\services\marketplace_service.py" "Marketplace import services - MarketplaceProduct"
-call :CreatePyFile "app\services\marketplace_product_service.py" "Marketplace staging services"
-call :CreatePyFile "app\services\product_service.py" "Vendor catalog services - Product"
-call :CreatePyFile "app\services\order_service.py" "Order services - vendor-scoped"
-call :CreatePyFile "app\services\payment_service.py" "Payment processing services"
-call :CreatePyFile "app\services\inventory_service.py" "Inventory services - vendor catalog"
-call :CreatePyFile "app\services\media_service.py" "File and media management services"
-call :CreatePyFile "app\services\notification_service.py" "Email and notification services"
-call :CreatePyFile "app\services\search_service.py" "Search and indexing services"
-call :CreatePyFile "app\services\cache_service.py" "Caching services"
-call :CreatePyFile "app\services\audit_service.py" "Audit logging services"
-call :CreatePyFile "app\services\monitoring_service.py" "Application monitoring services"
-call :CreatePyFile "app\services\backup_service.py" "Backup and recovery services"
-call :CreatePyFile "app\services\configuration_service.py" "Configuration management services"
-call :CreatePyFile "app\services\stats_service.py" "Statistics services - vendor-aware"
-
-:: Task files
-call :CreatePyFile "tasks\__init__.py" ""
-call :CreatePyFile "tasks\task_manager.py" "Celery configuration and task management"
-call :CreatePyFile "tasks\marketplace_import.py" "Marketplace CSV import tasks"
-call :CreatePyFile "tasks\email_tasks.py" "Email sending tasks"
-call :CreatePyFile "tasks\media_processing.py" "Image processing and optimization tasks"
-call :CreatePyFile "tasks\search_indexing.py" "Search index maintenance tasks"
-call :CreatePyFile "tasks\analytics_tasks.py" "Analytics and reporting tasks"
-call :CreatePyFile "tasks\cleanup_tasks.py" "Data cleanup and maintenance tasks"
-call :CreatePyFile "tasks\backup_tasks.py" "Backup and recovery tasks"
-
-:: Database model files
-call :CreatePyFile "models\__init__.py" ""
-call :CreatePyFile "models\database\__init__.py" "Import all models for easy access"
-call :CreatePyFile "models\database\base.py" "Base model class and common mixins"
-call :CreatePyFile "models\database\user.py" "User model - with vendor relationships"
-call :CreatePyFile "models\database\vendor.py" "Vendor, VendorUser, Role models"
-call :CreatePyFile "models\database\customer.py" "Customer, CustomerAddress models - vendor-scoped"
-call :CreatePyFile "models\database\marketplace_product.py" "MarketplaceProduct model - staging data"
-call :CreatePyFile "models\database\product.py" "Product model - vendor catalog"
-call :CreatePyFile "models\database\order.py" "Order, OrderItem models - vendor-scoped"
-call :CreatePyFile "models\database\payment.py" "Payment, PaymentMethod, VendorPaymentConfig models"
-call :CreatePyFile "models\database\inventory.py" "Inventory, InventoryMovement models - catalog products"
-call :CreatePyFile "models\database\marketplace.py" "MarketplaceImportJob model"
-call :CreatePyFile "models\database\media.py" "MediaFile, ProductMedia models"
-call :CreatePyFile "models\database\notification.py" "NotificationTemplate, NotificationQueue, NotificationLog models"
-call :CreatePyFile "models\database\search.py" "SearchIndex, SearchQuery models"
-call :CreatePyFile "models\database\audit.py" "AuditLog, DataExportLog models"
-call :CreatePyFile "models\database\monitoring.py" "PerformanceMetric, ErrorLog, SystemAlert models"
-call :CreatePyFile "models\database\backup.py" "BackupLog, RestoreLog models"
-call :CreatePyFile "models\database\configuration.py" "PlatformConfig, VendorConfig, FeatureFlag models"
-call :CreatePyFile "models\database\task.py" "TaskLog model"
-call :CreatePyFile "models\database\admin.py" "Admin-specific models"
-
-:: Schema model files
-call :CreatePyFile "models\schema\__init__.py" "Common imports"
-call :CreatePyFile "models\schema\base.py" "Base Pydantic models"
-call :CreatePyFile "models\schema\auth.py" "Login, Token, User response models"
-call :CreatePyFile "models\schema\vendor.py" "Vendor management models"
-call :CreatePyFile "models\schema\customer.py" "Customer request and response models"
-call :CreatePyFile "models\schema\team.py" "Team management models"
-call :CreatePyFile "models\schema\marketplace_product.py" "Marketplace staging models"
-call :CreatePyFile "models\schema\product.py" "Vendor catalog models"
-call :CreatePyFile "models\schema\order.py" "Order models - vendor-scoped"
-call :CreatePyFile "models\schema\payment.py" "Payment models"
-call :CreatePyFile "models\schema\inventory.py" "Inventory operation models"
-call :CreatePyFile "models\schema\marketplace.py" "Marketplace import job models"
-call :CreatePyFile "models\schema\media.py" "Media and file management models"
-call :CreatePyFile "models\schema\notification.py" "Notification models"
-call :CreatePyFile "models\schema\search.py" "Search models"
-call :CreatePyFile "models\schema\monitoring.py" "Monitoring models"
-call :CreatePyFile "models\schema\admin.py" "Admin operation models"
-call :CreatePyFile "models\schema\stats.py" "Statistics response models"
-
-:: Middleware files
-call :CreatePyFile "middleware\__init__.py" ""
-call :CreatePyFile "middleware\auth.py" "JWT authentication"
-call :CreatePyFile "middleware\vendor_context.py" "Vendor context detection and injection"
-call :CreatePyFile "middleware\rate_limiter.py" "Rate limiting"
-call :CreatePyFile "middleware\logging_middleware.py" "Request logging"
-call :CreatePyFile "middleware\decorators.py" "Cross-cutting concern decorators"
-
-:: Storage files
-call :CreatePyFile "storage\__init__.py" ""
-call :CreatePyFile "storage\backends.py" "Storage backend implementations"
-call :CreatePyFile "storage\utils.py" "Storage utilities"
-
-echo.
-echo Creating HTML files...
-echo.
-
-:: HTML files - Admin
-call :CreateHtmlFile "static\admin\login.html" "Admin login page"
-call :CreateHtmlFile "static\admin\dashboard.html" "Admin dashboard"
-call :CreateHtmlFile "static\admin\vendors.html" "Vendor management"
-call :CreateHtmlFile "static\admin\users.html" "User management"
-call :CreateHtmlFile "static\admin\marketplace.html" "System-wide marketplace monitoring"
-call :CreateHtmlFile "static\admin\monitoring.html" "System monitoring"
-
-:: HTML files - Vendor
-call :CreateHtmlFile "static\vendor\login.html" "Vendor team login"
-call :CreateHtmlFile "static\vendor\dashboard.html" "Vendor dashboard"
-call :CreateHtmlFile "static\vendor\admin\products.html" "Catalog management - Product table"
-call :CreateHtmlFile "static\vendor\admin\marketplace\imports.html" "Import jobs and history"
-call :CreateHtmlFile "static\vendor\admin\marketplace\browse.html" "Browse marketplace products - staging"
-call :CreateHtmlFile "static\vendor\admin\marketplace\selected.html" "Selected products - pre-publish"
-call :CreateHtmlFile "static\vendor\admin\marketplace\config.html" "Marketplace configuration"
-call :CreateHtmlFile "static\vendor\admin\orders.html" "Order management"
-call :CreateHtmlFile "static\vendor\admin\customers.html" "Customer management"
-call :CreateHtmlFile "static\vendor\admin\teams.html" "Team management"
-call :CreateHtmlFile "static\vendor\admin\inventory.html" "Inventory management - catalog products"
-call :CreateHtmlFile "static\vendor\admin\payments.html" "Payment configuration"
-call :CreateHtmlFile "static\vendor\admin\media.html" "Media library"
-call :CreateHtmlFile "static\vendor\admin\notifications.html" "Notification templates and logs"
-call :CreateHtmlFile "static\vendor\admin\settings.html" "Vendor settings"
-
-:: HTML files - Shop
-call :CreateHtmlFile "static\shop\home.html" "Shop homepage"
-call :CreateHtmlFile "static\shop\products.html" "Product catalog - Product table only"
-call :CreateHtmlFile "static\shop\product.html" "Product detail page"
-call :CreateHtmlFile "static\shop\search.html" "Search results page"
-call :CreateHtmlFile "static\shop\cart.html" "Shopping cart"
-call :CreateHtmlFile "static\shop\checkout.html" "Checkout process"
-call :CreateHtmlFile "static\shop\account\login.html" "Customer login"
-call :CreateHtmlFile "static\shop\account\register.html" "Customer registration"
-call :CreateHtmlFile "static\shop\account\profile.html" "Customer profile"
-call :CreateHtmlFile "static\shop\account\orders.html" "Order history"
-call :CreateHtmlFile "static\shop\account\addresses.html" "Address management"
-
-echo.
-echo Creating JavaScript files...
-echo.
-
-:: JavaScript files - Shared
-call :CreateJsFile "static\js\shared\vendor-context.js" "Vendor context detection and management"
-call :CreateJsFile "static\js\shared\api-client.js" "API communication utilities"
-call :CreateJsFile "static\js\shared\notification.js" "Notification handling"
-call :CreateJsFile "static\js\shared\media-upload.js" "File upload utilities"
-call :CreateJsFile "static\js\shared\search.js" "Search functionality"
-
-:: JavaScript files - Admin
-call :CreateJsFile "static\js\admin\dashboard.js" "Admin dashboard"
-call :CreateJsFile "static\js\admin\vendors.js" "Vendor management"
-call :CreateJsFile "static\js\admin\monitoring.js" "System monitoring"
-call :CreateJsFile "static\js\admin\analytics.js" "Admin analytics"
-
-:: JavaScript files - Vendor
-call :CreateJsFile "static\js\vendor\products.js" "Catalog management"
-call :CreateJsFile "static\js\vendor\marketplace.js" "Marketplace integration"
-call :CreateJsFile "static\js\vendor\orders.js" "Order management"
-call :CreateJsFile "static\js\vendor\payments.js" "Payment configuration"
-call :CreateJsFile "static\js\vendor\media.js" "Media management"
-call :CreateJsFile "static\js\vendor\dashboard.js" "Vendor dashboard"
-
-:: JavaScript files - Shop
-call :CreateJsFile "static\js\shop\catalog.js" "Product browsing"
-call :CreateJsFile "static\js\shop\search.js" "Product search"
-call :CreateJsFile "static\js\shop\cart.js" "Shopping cart"
-call :CreateJsFile "static\js\shop\checkout.js" "Checkout process"
-call :CreateJsFile "static\js\shop\account.js" "Customer account"
-
-echo.
-echo ========================================
-echo  Build Complete!
-echo ========================================
-echo.
-
-goto :eof
-
-:: Function to create directory if it doesn't exist
-:CreateDir
-if not exist "%~1" (
-    mkdir "%~1"
-    echo [CREATED] Directory: %~1
-) else (
-    echo [EXISTS]  Directory: %~1
-)
-goto :eof
-
-:: Function to create Python file if it doesn't exist
-:CreatePyFile
-if not exist "%~1" (
-    if "%~2"=="" (
-        echo. > "%~1"
-    ) else (
-        echo # %~2 > "%~1"
-    )
-    echo [CREATED] File: %~1
-) else (
-    echo [SKIPPED] File: %~1 - already exists
-)
-goto :eof
-
-:: Function to create HTML file if it doesn't exist
-:CreateHtmlFile
-if not exist "%~1" (
-    (
-        echo ^<!DOCTYPE html^>
-        echo ^<html lang="en"^>
-        echo ^<head^>
-        echo     ^<meta charset="UTF-8"^>
-        echo     ^<meta name="viewport" content="width=device-width, initial-scale=1.0"^>
-        echo     ^<title^>%~2^</title^>
-        echo ^</head^>
-        echo ^<body^>
-        echo     ^<!-- %~2 --^>
-        echo ^</body^>
-        echo ^</html^>
-    ) > "%~1"
-    echo [CREATED] File: %~1
-) else (
-    echo [SKIPPED] File: %~1 - already exists
-)
-goto :eof
-
-:: Function to create JavaScript file if it doesn't exist
-:CreateJsFile
-if not exist "%~1" (
-    echo // %~2 > "%~1"
-    echo [CREATED] File: %~1
-) else (
-    echo [SKIPPED] File: %~1 - already exists
-)
-goto :eof
diff --git a/docs/development/synology-github-repo.md b/docs/development/synology-github-repo.md
index dadce589..58509e1e 100644
--- a/docs/development/synology-github-repo.md
+++ b/docs/development/synology-github-repo.md
@@ -132,7 +132,7 @@ and then Permission and then tick boxes apply to sub folder and files
    Example:
 
    ```bash
-   git clone ssh://mygituser@192.168.1.2:/volume1/mysharefolder/myrepo1
+   git clone ssh://mygituser@192.168.1.2:/volume1/myreposfolder/myrepo1
    ```
 
 4. Access the cloned repository:
diff --git a/main.py b/main.py
index 4d69cbb3..6fdd8417 100644
--- a/main.py
+++ b/main.py
@@ -1,4 +1,14 @@
 # main.py
+"""
+Wizamart FastAPI Application
+
+Multi-tenant e-commerce marketplace platform with:
+- Three deployment modes (subdomain, custom domain, path-based)
+- Three interfaces (platform administration (admin), vendor dashboard (vendor), customer shop (shop))
+- Comprehensive exception handling
+- Middleware stack for context injection
+"""
+
 import sys
 import io
 
@@ -28,9 +38,11 @@ from app.core.database import get_db
 from app.core.lifespan import lifespan
 from app.exceptions.handler import setup_exception_handlers
 from app.exceptions import ServiceUnavailableException
-from middleware.context_middleware import context_middleware
-from middleware.theme_context import theme_context_middleware
-from middleware.vendor_context import vendor_context_middleware
+
+# Import REFACTORED class-based middleware
+from middleware.vendor_context import VendorContextMiddleware
+from middleware.context_middleware import ContextMiddleware
+from middleware.theme_context import ThemeContextMiddleware
 from middleware.logging_middleware import LoggingMiddleware
 
 logger = logging.getLogger(__name__)
@@ -63,23 +75,66 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
-# Add vendor context middleware (must be after CORS)
-app.middleware("http")(vendor_context_middleware)
+# ============================================================================
+# MIDDLEWARE REGISTRATION (CORRECTED ORDER!)
+# ============================================================================
+#
+# IMPORTANT: Middleware execution order with BaseHTTPMiddleware:
+#
+# When using app.add_middleware or wrapping with BaseHTTPMiddleware,
+# the LAST added middleware runs FIRST (LIFO - Last In, First Out).
+#
+# So we add them in REVERSE order of desired execution:
+#
+# Desired execution order:
+#   1. VendorContextMiddleware    (detect vendor, extract clean_path)
+#   2. ContextMiddleware          (detect context using clean_path)
+#   3. ThemeContextMiddleware     (load theme)
+#   4. LoggingMiddleware          (log all requests)
+#
+# Therefore we add them in REVERSE:
+#   - Add ThemeContextMiddleware FIRST (runs LAST in request)
+#   - Add ContextMiddleware SECOND
+#   - Add VendorContextMiddleware THIRD
+#   - Add LoggingMiddleware LAST (runs FIRST for timing)
+# ============================================================================
 
-# Add middleware (AFTER vendor_context_middleware)
-app.middleware("http")(context_middleware)
+logger.info("=" * 80)
+logger.info("MIDDLEWARE REGISTRATION")
+logger.info("=" * 80)
 
-# Add theme context middleware (must be after vendor context)
-app.middleware("http")(theme_context_middleware)
-
-# Add logging middleware (logs all requests/responses)
+# Add logging middleware (runs first for timing, logs all requests/responses)
+logger.info("Adding LoggingMiddleware (runs first for request timing)")
 app.add_middleware(LoggingMiddleware)
 
+# Add theme context middleware (runs last in request chain)
+logger.info("Adding ThemeContextMiddleware (detects and loads theme)")
+app.add_middleware(ThemeContextMiddleware)
+
+# Add context detection middleware (runs after vendor context extraction)
+logger.info("Adding ContextMiddleware (detects context type using clean_path)")
+app.add_middleware(ContextMiddleware)
+
+# Add vendor context middleware (runs first in request chain)
+logger.info("Adding VendorContextMiddleware (detects vendor, extracts clean_path)")
+app.add_middleware(VendorContextMiddleware)
+
+logger.info("=" * 80)
+logger.info("MIDDLEWARE ORDER SUMMARY:")
+logger.info("  Execution order (request →):")
+logger.info("    1. LoggingMiddleware (timing)")
+logger.info("    2. VendorContextMiddleware (vendor detection)")
+logger.info("    3. ContextMiddleware (context detection)")
+logger.info("    4. ThemeContextMiddleware (theme loading)")
+logger.info("    5. FastAPI Router")
+logger.info("=" * 80)
+
 # ========================================
 # MOUNT STATIC FILES - Use absolute path
 # ========================================
 if STATIC_DIR.exists():
     app.mount("/static", StaticFiles(directory=str(STATIC_DIR)), name="static")
+    logger.info(f"Mounted static files from: {STATIC_DIR}")
 else:
     logger.warning(f"Static directory not found at {STATIC_DIR}")
 # ========================================
@@ -87,7 +142,6 @@ else:
 # Include API router (JSON endpoints at /api/*)
 app.include_router(api_router, prefix="/api")
 
-
 # ============================================================================
 # FAVICON ROUTES (Must be registered BEFORE page routers)
 # ============================================================================
@@ -97,14 +151,12 @@ def serve_favicon() -> Response:
     Serve favicon with caching headers.
     Checks multiple possible locations for the favicon.
     """
-    # Possible favicon locations (in priority order)
     possible_paths = [
         STATIC_DIR / "favicon.ico",
         STATIC_DIR / "images" / "favicon.ico",
         STATIC_DIR / "assets" / "favicon.ico",
     ]
 
-    # Find first existing favicon
     for favicon_path in possible_paths:
         if favicon_path.exists():
             return FileResponse(
@@ -115,7 +167,6 @@ def serve_favicon() -> Response:
                 }
             )
 
-    # No favicon found - return 204 No Content
     return Response(status_code=204)
 
 
@@ -136,30 +187,60 @@ async def vendor_favicon():
 # ============================================================================
 # Include HTML page routes (these return rendered templates, not JSON)
 
+logger.info("=" * 80)
+logger.info("ROUTE REGISTRATION")
+logger.info("=" * 80)
+
 # Admin pages
+logger.info("Registering admin page routes: /admin/*")
 app.include_router(
     admin_pages.router,
     prefix="/admin",
     tags=["admin-pages"],
-    include_in_schema=False  # Don't show HTML pages in API docs
+    include_in_schema=False
 )
 
-# Vendor pages
+# Vendor management pages (dashboard, products, orders, etc.)
+logger.info("Registering vendor page routes: /vendor/{code}/*")
 app.include_router(
     vendor_pages.router,
     prefix="/vendor",
     tags=["vendor-pages"],
-    include_in_schema=False  # Don't show HTML pages in API docs
+    include_in_schema=False
 )
 
-# Shop pages
+# Customer shop pages - Register at TWO prefixes:
+# 1. /shop/* (for subdomain/custom domain modes)
+# 2. /vendors/{code}/shop/* (for path-based development mode)
+logger.info("Registering shop page routes:")
+logger.info("  - /shop/* (subdomain/custom domain mode)")
+logger.info("  - /vendors/{code}/shop/* (path-based development mode)")
+
 app.include_router(
     shop_pages.router,
     prefix="/shop",
     tags=["shop-pages"],
-    include_in_schema=False  # Don't show HTML pages in API docs
+    include_in_schema=False
 )
 
+app.include_router(
+    shop_pages.router,
+    prefix="/vendors/{vendor_code}/shop",
+    tags=["shop-pages"],
+    include_in_schema=False
+)
+
+logger.info("=" * 80)
+
+# Log all registered routes
+logger.info("=" * 80)
+logger.info("REGISTERED ROUTES SUMMARY")
+logger.info("=" * 80)
+for route in app.routes:
+    if hasattr(route, 'methods') and hasattr(route, 'path'):
+        methods = ', '.join(route.methods) if route.methods else 'N/A'
+        logger.info(f"  {methods:<10} {route.path:<60}")
+logger.info("=" * 80)
 
 # ============================================================================
 # API ROUTES (JSON Responses)
@@ -201,7 +282,8 @@ def health_check(db: Session = Depends(get_db)):
             ],
             "deployment_modes": [
                 "Subdomain-based (production): vendor.platform.com",
-                "Path-based (development): /vendor/vendorname/",
+                "Custom domain (production): customvendordomain.com",
+                "Path-based (development): /vendors/vendorname/ or /vendor/vendorname/",
             ],
             "auth_required": "Most endpoints require Bearer token authentication",
         }
diff --git a/middleware/context_middleware.py b/middleware/context_middleware.py
index 1deec698..60a28b5c 100644
--- a/middleware/context_middleware.py
+++ b/middleware/context_middleware.py
@@ -1,14 +1,23 @@
 # middleware/context_middleware.py
 """
-Context Detection Middleware
+Context Detection Middleware (Class-Based)
 
 Detects the request context type (API, Admin, Vendor Dashboard, Shop, or Fallback)
 and injects it into request.state for use by error handlers and other components.
 
-This middleware runs independently and complements vendor_context_middleware.
+MUST run AFTER vendor_context_middleware to have access to clean_path.
+MUST run BEFORE theme_context_middleware (which needs context_type).
+
+Class-based middleware provides:
+- Better state management
+- Easier testing
+- More organized code
+- Standard ASGI pattern
 """
+
 import logging
 from enum import Enum
+from starlette.middleware.base import BaseHTTPMiddleware
 from fastapi import Request
 
 logger = logging.getLogger(__name__)
@@ -38,42 +47,68 @@ class ContextManager:
         4. Shop → Vendor storefront (custom domain, subdomain, or shop paths)
         5. Fallback → Unknown/generic context
 
+        CRITICAL: Uses clean_path (if available) instead of original path.
+        This ensures correct context detection for path-based routing.
+
         Args:
             request: FastAPI request object
 
         Returns:
             RequestContext enum value
         """
-        path = request.url.path
+        # Use clean_path if available (extracted by vendor_context_middleware)
+        # Falls back to original path if clean_path not set
+        # This is critical for correct context detection with path-based routing
+        path = getattr(request.state, 'clean_path', request.url.path)
+
         host = request.headers.get("host", "")
 
         # Remove port from host if present
         if ":" in host:
             host = host.split(":")[0]
 
+        logger.debug(
+            f"[CONTEXT] Detecting context",
+            extra={
+                "original_path": request.url.path,
+                "clean_path": getattr(request.state, 'clean_path', 'NOT SET'),
+                "path_to_check": path,
+                "host": host,
+            }
+        )
+
         # 1. API context (highest priority)
         if path.startswith("/api/"):
+            logger.debug("[CONTEXT] Detected as API", extra={"path": path})
             return RequestContext.API
 
         # 2. Admin context
         if ContextManager._is_admin_context(request, host, path):
+            logger.debug("[CONTEXT] Detected as ADMIN", extra={"path": path, "host": host})
             return RequestContext.ADMIN
 
         # 3. Vendor Dashboard context (vendor management area)
         if ContextManager._is_vendor_dashboard_context(path):
+            logger.debug("[CONTEXT] Detected as VENDOR_DASHBOARD", extra={"path": path})
             return RequestContext.VENDOR_DASHBOARD
 
         # 4. Shop context (vendor storefront)
         # Check if vendor context exists (set by vendor_context_middleware)
         if hasattr(request.state, 'vendor') and request.state.vendor:
             # If we have a vendor and it's not admin or vendor dashboard, it's shop
+            logger.debug(
+                "[CONTEXT] Detected as SHOP (has vendor context)",
+                extra={"vendor": request.state.vendor.name}
+            )
             return RequestContext.SHOP
 
         # Also check shop-specific paths
         if path.startswith("/shop/"):
+            logger.debug("[CONTEXT] Detected as SHOP (from path)", extra={"path": path})
             return RequestContext.SHOP
 
         # 5. Fallback for unknown contexts
+        logger.debug("[CONTEXT] Detected as FALLBACK", extra={"path": path})
         return RequestContext.FALLBACK
 
     @staticmethod
@@ -92,43 +127,59 @@ class ContextManager:
     @staticmethod
     def _is_vendor_dashboard_context(path: str) -> bool:
         """Check if request is in vendor dashboard context."""
-        # Vendor dashboard paths (/vendor/*)
+        # Vendor dashboard paths (/vendor/{code}/*)
         # Note: This is the vendor management area, not the shop
-        if path.startswith("/vendor/"):
+        # Important: /vendors/{code}/shop/* should NOT match this
+        if path.startswith("/vendor/") and not path.startswith("/vendors/"):
             return True
 
         return False
 
 
-async def context_middleware(request: Request, call_next):
+class ContextMiddleware(BaseHTTPMiddleware):
     """
     Middleware to detect and inject request context into request.state.
 
-    This should run AFTER vendor_context_middleware to have access to
-    vendor information if available.
+    Class-based middleware provides:
+    - Better lifecycle management
+    - Easier to test and extend
+    - Standard ASGI pattern
+    - Clear separation of concerns
 
-    Injects:
+    Runs SECOND in middleware chain (after vendor_context_middleware).
+    Depends on:
+        request.state.clean_path (set by vendor_context_middleware)
+        request.state.vendor (set by vendor_context_middleware)
+
+    Sets:
         request.state.context_type: RequestContext enum value
     """
-    # Detect context
-    context_type = ContextManager.detect_context(request)
 
-    # Inject into request state
-    request.state.context_type = context_type
+    async def dispatch(self, request: Request, call_next):
+        """
+        Detect context and inject into request state.
+        """
+        # Detect context
+        context_type = ContextManager.detect_context(request)
 
-    # Log context detection (debug level)
-    logger.debug(
-        f"[CONTEXT] Request context detected: {context_type.value}",
-        extra={
-            "path": request.url.path,
-            "host": request.headers.get("host", ""),
-            "context": context_type.value,
-        }
-    )
+        # Inject into request state
+        request.state.context_type = context_type
 
-    # Continue processing
-    response = await call_next(request)
-    return response
+        # Log context detection with full details
+        logger.debug(
+            f"[CONTEXT_MIDDLEWARE] Context detected: {context_type.value}",
+            extra={
+                "path": request.url.path,
+                "clean_path": getattr(request.state, 'clean_path', 'NOT SET'),
+                "host": request.headers.get("host", ""),
+                "context": context_type.value,
+                "has_vendor": hasattr(request.state, 'vendor') and request.state.vendor is not None,
+            }
+        )
+
+        # Continue processing
+        response = await call_next(request)
+        return response
 
 
 def get_request_context(request: Request) -> RequestContext:
diff --git a/middleware/path_rewrite_middleware.py b/middleware/path_rewrite_middleware.py
new file mode 100644
index 00000000..692702c0
--- /dev/null
+++ b/middleware/path_rewrite_middleware.py
@@ -0,0 +1,63 @@
+# middleware/path_rewrite_middleware.py
+"""
+Path Rewrite Middleware
+
+Rewrites request paths for path-based vendor routing.
+This allows /vendor/VENDORCODE/shop/products to be routed as /shop/products
+
+MUST run AFTER vendor_context_middleware and BEFORE context_middleware.
+"""
+import logging
+from fastapi import Request
+from starlette.datastructures import URL
+
+logger = logging.getLogger(__name__)
+
+
+async def path_rewrite_middleware(request: Request, call_next):
+    """
+    Middleware to rewrite request paths for vendor context.
+
+    If vendor_context_middleware set request.state.clean_path, this middleware
+    will rewrite the request path to use the clean path instead.
+
+    This allows FastAPI route matching to work correctly with path-based routing.
+
+    Example:
+        Original: /vendor/WIZAMART/shop/products
+        Clean path: /shop/products
+        After rewrite: Request is routed as if path was /shop/products
+
+    MUST run after vendor_context_middleware (which sets clean_path)
+    MUST run before context_middleware (which needs to see the clean path)
+    """
+
+    # Check if vendor_context_middleware set a clean_path
+    if hasattr(request.state, 'clean_path'):
+        clean_path = request.state.clean_path
+        original_path = request.url.path
+
+        # Only rewrite if clean_path is different from original path
+        if clean_path != original_path:
+            logger.debug(
+                f"[PATH_REWRITE] Rewriting path",
+                extra={
+                    "original_path": original_path,
+                    "clean_path": clean_path,
+                    "vendor": getattr(request.state, 'vendor', 'NOT SET'),
+                }
+            )
+
+            # Rewrite the path by modifying the request's scope
+            # This affects how FastAPI's router will see the path
+            request.scope['path'] = clean_path
+
+            # Also update request._url to reflect the change
+            # This ensures request.url.path returns the rewritten path
+            old_url = request.url
+            new_url = old_url.replace(path=clean_path)
+            request._url = new_url
+
+    # Continue to next middleware/handler
+    response = await call_next(request)
+    return response
diff --git a/middleware/theme_context.py b/middleware/theme_context.py
index fa6b6b21..a7531eae 100644
--- a/middleware/theme_context.py
+++ b/middleware/theme_context.py
@@ -1,9 +1,17 @@
 # middleware/theme_context.py
 """
-Theme Context Middleware
-Injects vendor-specific theme into request context
+Theme Context Middleware (Class-Based)
+
+Injects vendor-specific theme into request context.
+
+Class-based middleware provides:
+- Better state management
+- Easier testing
+- Standard ASGI pattern
 """
+
 import logging
+from starlette.middleware.base import BaseHTTPMiddleware
 from fastapi import Request
 from sqlalchemy.orm import Session
 
@@ -31,7 +39,7 @@ class ThemeContextManager:
             return theme.to_dict()
 
         # Return default theme
-        return get_default_theme()
+        return ThemeContextManager.get_default_theme()
 
     @staticmethod
     def get_default_theme() -> dict:
@@ -76,40 +84,68 @@ class ThemeContextManager:
         }
 
 
-async def theme_context_middleware(request: Request, call_next):
+class ThemeContextMiddleware(BaseHTTPMiddleware):
     """
     Middleware to inject theme context into request state.
 
-    This runs AFTER vendor_context_middleware has set request.state.vendor
+    Class-based middleware provides:
+    - Better state management
+    - Easier testing
+    - Standard ASGI pattern
+
+    Runs LAST in middleware chain (after vendor_context_middleware and context_middleware).
+    Depends on:
+        request.state.vendor (set by vendor_context_middleware)
+
+    Sets:
+        request.state.theme: Theme dictionary
     """
-    # Only inject theme for shop pages (not admin or API)
-    if hasattr(request.state, 'vendor') and request.state.vendor:
-        vendor = request.state.vendor
 
-        # Get database session
-        db_gen = get_db()
-        db = next(db_gen)
+    async def dispatch(self, request: Request, call_next):
+        """
+        Load and inject theme context.
+        """
+        # Only inject theme for shop pages (not admin or API)
+        if hasattr(request.state, 'vendor') and request.state.vendor:
+            vendor = request.state.vendor
 
-        try:
-            # Get vendor theme
-            theme = ThemeContextManager.get_vendor_theme(db, vendor.id)
-            request.state.theme = theme
+            # Get database session
+            db_gen = get_db()
+            db = next(db_gen)
 
-            logger.debug(
-                f"Theme loaded for vendor {vendor.name}: {theme['theme_name']}"
-            )
-        except Exception as e:
-            logger.error(f"Failed to load theme for vendor {vendor.id}: {e}")
-            # Fallback to default theme
+            try:
+                # Get vendor theme
+                theme = ThemeContextManager.get_vendor_theme(db, vendor.id)
+                request.state.theme = theme
+
+                logger.debug(
+                    f"[THEME] Theme loaded for vendor",
+                    extra={
+                        "vendor_id": vendor.id,
+                        "vendor_name": vendor.name,
+                        "theme_name": theme.get('theme_name', 'default'),
+                    }
+                )
+            except Exception as e:
+                logger.error(
+                    f"[THEME] Failed to load theme for vendor {vendor.id}: {e}",
+                    exc_info=True
+                )
+                # Fallback to default theme
+                request.state.theme = ThemeContextManager.get_default_theme()
+            finally:
+                db.close()
+        else:
+            # No vendor context, use default theme
             request.state.theme = ThemeContextManager.get_default_theme()
-        finally:
-            db.close()
-    else:
-        # No vendor context, use default theme
-        request.state.theme = ThemeContextManager.get_default_theme()
+            logger.debug(
+                "[THEME] No vendor context, using default theme",
+                extra={"has_vendor": False}
+            )
 
-    response = await call_next(request)
-    return response
+        # Continue processing
+        response = await call_next(request)
+        return response
 
 
 def get_current_theme(request: Request) -> dict:
diff --git a/middleware/vendor_context.py b/middleware/vendor_context.py
index 9b78564f..f76357a2 100644
--- a/middleware/vendor_context.py
+++ b/middleware/vendor_context.py
@@ -1,9 +1,22 @@
 # middleware/vendor_context.py
+"""
+Vendor Context Middleware (Class-Based)
+
+Detects vendor from host/domain/path and injects into request.state.
+Handles three routing modes:
+1. Custom domains (customdomain1.com → Vendor 1)
+2. Subdomains (vendor1.platform.com → Vendor 1)
+3. Path-based (/vendor/vendor1/ or /vendors/vendor1/ → Vendor 1)
+
+Also extracts clean_path for nested routing patterns.
+"""
+
 import logging
 from typing import Optional
-from fastapi import Request
 from sqlalchemy.orm import Session
-from sqlalchemy import func, or_
+from sqlalchemy import func
+from starlette.middleware.base import BaseHTTPMiddleware
+from fastapi import Request
 
 from app.core.database import get_db
 from models.database.vendor import Vendor
@@ -23,7 +36,7 @@ class VendorContextManager:
         Priority order:
         1. Custom domain (customdomain1.com)
         2. Subdomain (vendor1.platform.com)
-        3. Path-based (/vendor/vendor1/)
+        3. Path-based (/vendor/vendor1/ or /vendors/vendor1/)
 
         Returns dict with vendor info or None if not found.
         """
@@ -48,7 +61,6 @@ class VendorContextManager:
         )
 
         if is_custom_domain:
-            # This could be a custom domain like customdomain1.com
             normalized_domain = VendorDomain.normalize_domain(host)
             return {
                 "domain": normalized_domain,
@@ -69,15 +81,23 @@ class VendorContextManager:
                     "host": host
                 }
 
-        # Method 3: Path-based detection (/vendor/vendorname/) - for development
-        if path.startswith("/vendor/"):
-            path_parts = path.split("/")
-            if len(path_parts) >= 3:
-                subdomain = path_parts[2]
+        # Method 3: Path-based detection (/vendor/vendorname/ or /vendors/vendorname/)
+        # Support BOTH patterns for flexibility
+        if path.startswith("/vendor/") or path.startswith("/vendors/"):
+            # Determine which pattern
+            if path.startswith("/vendors/"):
+                prefix_len = len("/vendors/")
+            else:
+                prefix_len = len("/vendor/")
+
+            path_parts = path[prefix_len:].split("/")
+            if len(path_parts) >= 1 and path_parts[0]:
+                vendor_code = path_parts[0]
                 return {
-                    "subdomain": subdomain,
+                    "subdomain": vendor_code,
                     "detection_method": "path",
-                    "path_prefix": f"/vendor/{subdomain}",
+                    "path_prefix": path[:prefix_len + len(vendor_code)],
+                    "full_prefix": path[:prefix_len],  # /vendor/ or /vendors/
                     "host": host
                 }
 
@@ -102,7 +122,6 @@ class VendorContextManager:
         if context.get("detection_method") == "custom_domain":
             domain = context.get("domain")
             if domain:
-                # Look up vendor by custom domain
                 vendor_domain = (
                     db.query(VendorDomain)
                     .filter(VendorDomain.domain == domain)
@@ -113,12 +132,11 @@ class VendorContextManager:
 
                 if vendor_domain:
                     vendor = vendor_domain.vendor
-                    # Check if vendor is active
                     if not vendor or not vendor.is_active:
                         logger.warning(f"Vendor for domain {domain} is not active")
                         return None
 
-                    logger.info(f"[OK] Vendor found via custom domain: {domain} -> {vendor.name}")
+                    logger.info(f"[OK] Vendor found via custom domain: {domain} → {vendor.name}")
                     return vendor
                 else:
                     logger.warning(f"No active vendor found for custom domain: {domain}")
@@ -127,7 +145,6 @@ class VendorContextManager:
         # Method 2 & 3: Subdomain or path-based lookup
         if "subdomain" in context:
             subdomain = context["subdomain"]
-            # Query vendor by subdomain (case-insensitive)
             vendor = (
                 db.query(Vendor)
                 .filter(func.lower(Vendor.subdomain) == subdomain.lower())
@@ -137,7 +154,7 @@ class VendorContextManager:
 
             if vendor:
                 method = context.get("detection_method", "unknown")
-                logger.info(f"[OK] Vendor found via {method}: {subdomain} -> {vendor.name}")
+                logger.info(f"[OK] Vendor found via {method}: {subdomain} → {vendor.name}")
             else:
                 logger.warning(f"No active vendor found for subdomain: {subdomain}")
 
@@ -145,14 +162,19 @@ class VendorContextManager:
 
     @staticmethod
     def extract_clean_path(request: Request, vendor_context: Optional[dict]) -> str:
-        """Extract clean path without vendor prefix for routing."""
+        """
+        Extract clean path without vendor prefix for routing.
+
+        Supports both /vendor/ and /vendors/ prefixes.
+        """
         if not vendor_context:
             return request.url.path
 
         # Only strip path prefix for path-based detection
         if vendor_context.get("detection_method") == "path":
-            path_prefix = vendor_context.get("path_prefix", "")
             path = request.url.path
+            path_prefix = vendor_context.get("path_prefix", "")
+
             if path.startswith(path_prefix):
                 clean_path = path[len(path_prefix):]
                 return clean_path if clean_path else "/"
@@ -165,15 +187,12 @@ class VendorContextManager:
         host = request.headers.get("host", "")
         path = request.url.path
 
-        # Remove port from host
         if ":" in host:
             host = host.split(":")[0]
 
-        # Check for admin subdomain
         if host.startswith("admin."):
             return True
 
-        # Check for admin path
         if path.startswith("/admin"):
             return True
 
@@ -189,82 +208,118 @@ class VendorContextManager:
         """Check if request is for static files."""
         path = request.url.path.lower()
 
-        # Static file extensions
         static_extensions = (
             '.ico', '.css', '.js', '.png', '.jpg', '.jpeg', '.gif', '.svg',
             '.woff', '.woff2', '.ttf', '.eot', '.webp', '.map', '.json',
             '.xml', '.txt', '.pdf', '.webmanifest'
         )
 
-        # Static paths
         static_paths = ('/static/', '/media/', '/assets/', '/.well-known/')
 
-        # Check if it's a static file by extension
         if path.endswith(static_extensions):
             return True
 
-        # Check if it's in a static directory
         if any(path.startswith(static_path) for static_path in static_paths):
             return True
 
-        # Special case: favicon.ico at any level
         if 'favicon.ico' in path:
             return True
 
         return False
 
 
-async def vendor_context_middleware(request: Request, call_next):
+class VendorContextMiddleware(BaseHTTPMiddleware):
     """
     Middleware to inject vendor context into request state.
 
-    Handles three routing modes:
-    1. Custom domains (customdomain1.com -> Vendor 1)
-    2. Subdomains (vendor1.platform.com -> Vendor 1)
-    3. Path-based (/vendor/vendor1/ -> Vendor 1)
+    Class-based middleware provides:
+    - Better state management
+    - Easier testing
+    - More organized code
+    - Standard ASGI pattern
+
+    Runs FIRST in middleware chain.
+    Sets:
+        request.state.vendor: Vendor object
+        request.state.vendor_context: Detection metadata
+        request.state.clean_path: Path without vendor prefix
     """
-    # Skip vendor detection for admin, API, static files, and system requests
-    if (VendorContextManager.is_admin_request(request) or
-            VendorContextManager.is_api_request(request) or
-            VendorContextManager.is_static_file_request(request) or
-            request.url.path in ["/", "/health", "/docs", "/redoc", "/openapi.json"]):
+
+    async def dispatch(self, request: Request, call_next):
+        """
+        Detect and inject vendor context.
+        """
+        # Skip vendor detection for admin, API, static files, and system requests
+        if (
+                VendorContextManager.is_admin_request(request) or
+                VendorContextManager.is_api_request(request) or
+                VendorContextManager.is_static_file_request(request) or
+                request.url.path in ["/", "/health", "/docs", "/redoc", "/openapi.json"]
+        ):
+            logger.debug(
+                f"[VENDOR] Skipping vendor detection: {request.url.path}",
+                extra={"path": request.url.path, "reason": "admin/api/static/system"}
+            )
+            request.state.vendor = None
+            request.state.vendor_context = None
+            request.state.clean_path = request.url.path
+            return await call_next(request)
+
+        # Detect vendor context
+        vendor_context = VendorContextManager.detect_vendor_context(request)
+
+        if vendor_context:
+            db_gen = get_db()
+            db = next(db_gen)
+            try:
+                vendor = VendorContextManager.get_vendor_from_context(db, vendor_context)
+
+                if vendor:
+                    request.state.vendor = vendor
+                    request.state.vendor_context = vendor_context
+                    request.state.clean_path = VendorContextManager.extract_clean_path(
+                        request, vendor_context
+                    )
+
+                    logger.debug(
+                        f"[VENDOR_CONTEXT] Vendor detected",
+                        extra={
+                            "vendor_id": vendor.id,
+                            "vendor_name": vendor.name,
+                            "vendor_subdomain": vendor.subdomain,
+                            "detection_method": vendor_context.get("detection_method"),
+                            "original_path": request.url.path,
+                            "clean_path": request.state.clean_path,
+                        }
+                    )
+                else:
+                    logger.warning(
+                        f"[WARNING] Vendor context detected but vendor not found",
+                        extra={
+                            "context": vendor_context,
+                            "detection_method": vendor_context.get("detection_method"),
+                        }
+                    )
+                    request.state.vendor = None
+                    request.state.vendor_context = vendor_context
+                    request.state.clean_path = request.url.path
+            finally:
+                db.close()
+        else:
+            logger.debug(
+                f"[VENDOR] No vendor context detected",
+                extra={
+                    "path": request.url.path,
+                    "host": request.headers.get("host", ""),
+                }
+            )
+            request.state.vendor = None
+            request.state.vendor_context = None
+            request.state.clean_path = request.url.path
+
+        # Continue to next middleware
         return await call_next(request)
 
-    # Detect vendor context
-    vendor_context = VendorContextManager.detect_vendor_context(request)
-
-    if vendor_context:
-        db_gen = get_db()
-        db = next(db_gen)
-        try:
-            vendor = VendorContextManager.get_vendor_from_context(db, vendor_context)
-
-            if vendor:
-                request.state.vendor = vendor
-                request.state.vendor_context = vendor_context
-                request.state.clean_path = VendorContextManager.extract_clean_path(
-                    request, vendor_context
-                )
-
-                logger.debug(
-                    f"[VENDOR] Vendor context: {vendor.name} ({vendor.subdomain}) "
-                    f"via {vendor_context['detection_method']}"
-                )
-            else:
-                logger.warning(
-                    f"[WARNING] Vendor not found for context: {vendor_context}"
-                )
-                request.state.vendor = None
-                request.state.vendor_context = vendor_context
-        finally:
-            db.close()
-    else:
-        request.state.vendor = None
-        request.state.vendor_context = None
-        request.state.clean_path = request.url.path
-
-    return await call_next(request)
-
 
 def get_current_vendor(request: Request) -> Optional[Vendor]:
     """Helper function to get current vendor from request state."""
diff --git a/models/database/vendor.py b/models/database/vendor.py
index a29042bf..0a3c1037 100644
--- a/models/database/vendor.py
+++ b/models/database/vendor.py
@@ -164,7 +164,6 @@ class Vendor(Base, TimestampMixin):
         return domains
 
 
-# Keep your existing VendorUser and Role models unchanged
 class VendorUser(Base, TimestampMixin):
     __tablename__ = "vendor_users"
 
diff --git a/scripts/seed_database.py b/scripts/seed_database.py
index 88a2a44c..7d8c7d6f 100644
--- a/scripts/seed_database.py
+++ b/scripts/seed_database.py
@@ -1,102 +1,396 @@
 #!/usr/bin/env python3
 """
-Seed the database with initial development data.
+Enhanced Database Seeder for Wizamart Platform
 
-Creates:
-- Admin user (admin/admin123)
-- Test vendors (TESTVENDOR, WIZAMART)
+Creates comprehensive test data including:
+- Admin and regular users
+- Multiple vendors with themes and domains
+- Products and marketplace products
+- Customers and addresses
+- Orders and order items
+- Inventory records
+- Import jobs
+- Admin settings and platform alerts
 
 Usage:
-    python scripts/seed_database.py
+    python scripts/seed_database.py [--reset] [--minimal]
 
-This script is idempotent - safe to run multiple times.
+    --reset    : Drop all data before seeding (destructive!)
+    --minimal  : Create only essential data (admin + 1 vendor)
+
+Or via Makefile:
+    make seed           # Normal seeding
+    make seed-reset     # Reset and seed
+    make seed-minimal   # Minimal seeding
+
+This script is idempotent when run without --reset.
 """
 
 import sys
+import argparse
 from pathlib import Path
+from typing import Dict, List, Tuple
+from datetime import datetime, timezone, timedelta
+from decimal import Decimal
 
 # Add project root to path
 project_root = Path(__file__).parent.parent
 sys.path.insert(0, str(project_root))
 
 from sqlalchemy.orm import Session
-from sqlalchemy import select
+from sqlalchemy import select, delete
 
 from app.core.database import SessionLocal, engine
 from models.database.user import User
-from models.database.vendor import Vendor
+from models.database.vendor import Vendor, VendorUser, Role
+from models.database.vendor_domain import VendorDomain
+from models.database.vendor_theme import VendorTheme
+from models.database.customer import Customer, CustomerAddress
+from models.database.product import Product
+from models.database.marketplace_product import MarketplaceProduct
+from models.database.marketplace_import_job import MarketplaceImportJob
+from models.database.order import Order, OrderItem
+from models.database.admin import AdminSetting, PlatformAlert
 from middleware.auth import AuthManager
-from datetime import datetime, timezone
 
-# Default credentials
+# =============================================================================
+# CONFIGURATION
+# =============================================================================
+
 DEFAULT_ADMIN_EMAIL = "admin@wizamart.com"
 DEFAULT_ADMIN_USERNAME = "admin"
 DEFAULT_ADMIN_PASSWORD = "admin123"  # Change in production!
 
+VENDOR_CONFIGS = [
+    {
+        "vendor_code": "WIZAMART",
+        "name": "WizaMart",
+        "subdomain": "wizamart",
+        "description": "Premium electronics and gadgets marketplace",
+        "theme_preset": "modern",
+        "custom_domain": "wizamart.shop",
+    },
+    {
+        "vendor_code": "FASHIONHUB",
+        "name": "Fashion Hub",
+        "subdomain": "fashionhub",
+        "description": "Trendy clothing and accessories",
+        "theme_preset": "vibrant",
+        "custom_domain": "fashionhub.store",
+    },
+    {
+        "vendor_code": "BOOKSTORE",
+        "name": "The Book Store",
+        "subdomain": "bookstore",
+        "description": "Books, magazines, and educational materials",
+        "theme_preset": "classic",
+        "custom_domain": None,
+    },
+]
+
+TEST_USERS = [
+    {
+        "username": "vendor1",
+        "email": "vendor1@example.com",
+        "password": "password123",
+        "role": "vendor",
+        "first_name": "John",
+        "last_name": "Vendor",
+    },
+    {
+        "username": "vendor2",
+        "email": "vendor2@example.com",
+        "password": "password123",
+        "role": "vendor",
+        "first_name": "Jane",
+        "last_name": "Merchant",
+    },
+    {
+        "username": "customer1",
+        "email": "customer1@example.com",
+        "password": "password123",
+        "role": "customer",
+        "first_name": "Alice",
+        "last_name": "Customer",
+    },
+]
+
+THEME_PRESETS = {
+    "default": {
+        "theme_name": "default",
+        "colors": {
+            "primary": "#6366f1",
+            "secondary": "#8b5cf6",
+            "accent": "#ec4899",
+            "background": "#ffffff",
+            "text": "#1f2937",
+            "border": "#e5e7eb"
+        },
+        "font_family_heading": "Inter, sans-serif",
+        "font_family_body": "Inter, sans-serif",
+        "layout_style": "grid",
+        "header_style": "fixed",
+        "product_card_style": "modern",
+    },
+    "modern": {
+        "theme_name": "modern",
+        "colors": {
+            "primary": "#3b82f6",
+            "secondary": "#06b6d4",
+            "accent": "#f59e0b",
+            "background": "#f9fafb",
+            "text": "#111827",
+            "border": "#d1d5db"
+        },
+        "font_family_heading": "Poppins, sans-serif",
+        "font_family_body": "Inter, sans-serif",
+        "layout_style": "grid",
+        "header_style": "transparent",
+        "product_card_style": "modern",
+    },
+    "classic": {
+        "theme_name": "classic",
+        "colors": {
+            "primary": "#1e40af",
+            "secondary": "#7c3aed",
+            "accent": "#dc2626",
+            "background": "#ffffff",
+            "text": "#374151",
+            "border": "#e5e7eb"
+        },
+        "font_family_heading": "Georgia, serif",
+        "font_family_body": "Georgia, serif",
+        "layout_style": "list",
+        "header_style": "fixed",
+        "product_card_style": "classic",
+    },
+    "vibrant": {
+        "theme_name": "vibrant",
+        "colors": {
+            "primary": "#ec4899",
+            "secondary": "#f59e0b",
+            "accent": "#8b5cf6",
+            "background": "#fef3c7",
+            "text": "#78350f",
+            "border": "#fbbf24"
+        },
+        "font_family_heading": "Montserrat, sans-serif",
+        "font_family_body": "Open Sans, sans-serif",
+        "layout_style": "masonry",
+        "header_style": "static",
+        "product_card_style": "modern",
+    },
+    "minimal": {
+        "theme_name": "minimal",
+        "colors": {
+            "primary": "#000000",
+            "secondary": "#404040",
+            "accent": "#737373",
+            "background": "#ffffff",
+            "text": "#171717",
+            "border": "#e5e5e5"
+        },
+        "font_family_heading": "Helvetica, Arial, sans-serif",
+        "font_family_body": "Helvetica, Arial, sans-serif",
+        "layout_style": "grid",
+        "header_style": "static",
+        "product_card_style": "minimal",
+    },
+}
+
+SAMPLE_PRODUCTS = [
+    {
+        "marketplace_product_id": "PROD-001",
+        "title": "Wireless Bluetooth Headphones",
+        "description": "Premium noise-cancelling wireless headphones with 30-hour battery life",
+        "price": "149.99",
+        "brand": "AudioTech",
+        "gtin": "1234567890123",
+        "availability": "in stock",
+        "condition": "new",
+        "google_product_category": "Electronics > Audio > Headphones",
+    },
+    {
+        "marketplace_product_id": "PROD-002",
+        "title": "Smart Watch Pro",
+        "description": "Advanced fitness tracking with heart rate monitor and GPS",
+        "price": "299.99",
+        "brand": "TechWear",
+        "gtin": "1234567890124",
+        "availability": "in stock",
+        "condition": "new",
+        "google_product_category": "Electronics > Wearables > Smart Watches",
+    },
+    {
+        "marketplace_product_id": "PROD-003",
+        "title": "Portable Bluetooth Speaker",
+        "description": "Waterproof speaker with 360° sound and 12-hour battery",
+        "price": "79.99",
+        "brand": "AudioTech",
+        "gtin": "1234567890125",
+        "availability": "in stock",
+        "condition": "new",
+        "google_product_category": "Electronics > Audio > Speakers",
+    },
+    {
+        "marketplace_product_id": "PROD-004",
+        "title": "Wireless Charging Pad",
+        "description": "Fast wireless charging for all Qi-enabled devices",
+        "price": "39.99",
+        "brand": "ChargeMax",
+        "gtin": "1234567890126",
+        "availability": "in stock",
+        "condition": "new",
+        "google_product_category": "Electronics > Accessories > Chargers",
+    },
+    {
+        "marketplace_product_id": "PROD-005",
+        "title": "4K Webcam",
+        "description": "Ultra HD webcam with auto-focus and built-in microphone",
+        "price": "129.99",
+        "brand": "VisionTech",
+        "gtin": "1234567890127",
+        "availability": "preorder",
+        "condition": "new",
+        "google_product_category": "Electronics > Computers > Webcams",
+    },
+]
+
+
+# =============================================================================
+# UTILITY FUNCTIONS
+# =============================================================================
+
+def print_section(title: str, char: str = "="):
+    """Print a formatted section header."""
+    width = 70
+    print(f"\n{char * width}")
+    print(f"{title.center(width)}")
+    print(f"{char * width}\n")
+
+
+def print_step(step_num: int, description: str):
+    """Print a step header."""
+    print(f"STEP {step_num}: {description}")
+
+
+def print_success(message: str):
+    """Print a success message."""
+    print(f"  ✓ {message}")
+
+
+def print_info(message: str):
+    """Print an info message."""
+    print(f"  ℹ️  {message}")
+
+
+def print_error(message: str):
+    """Print an error message."""
+    print(f"  ✗ {message}")
+
 
 def verify_database_ready() -> bool:
-    """
-    Verify that database tables exist.
-
-    Returns:
-        bool: True if database is ready, False otherwise
-    """
+    """Verify that database tables exist."""
     try:
         with engine.connect() as conn:
             from sqlalchemy import text
-            # Check for users table
-            result = conn.execute(
-                text("SELECT name FROM sqlite_master WHERE type='table' AND name='users'")
-            )
-            users_table = result.fetchall()
 
-            # Check for vendors table
-            result = conn.execute(
-                text("SELECT name FROM sqlite_master WHERE type='table' AND name='vendors'")
-            )
-            vendors_table = result.fetchall()
+            required_tables = ['users', 'vendors', 'products', 'marketplace_products']
 
-            return len(users_table) > 0 and len(vendors_table) > 0
+            for table in required_tables:
+                result = conn.execute(
+                    text(f"SELECT name FROM sqlite_master WHERE type='table' AND name='{table}'")
+                )
+                if not result.fetchall():
+                    print_error(f"Required table '{table}' not found")
+                    return False
+
+            return True
 
     except Exception as e:
-        print(f"❌ Error checking database: {e}")
+        print_error(f"Error checking database: {e}")
         return False
 
 
-def create_admin_user(db: Session, auth_manager: AuthManager) -> tuple[User, bool]:
-    """
-    Create admin user if it doesn't exist.
+def reset_database(db: Session):
+    """Delete all data from database (destructive!)."""
+    print_section("RESETTING DATABASE", "!")
+    print("⚠️  WARNING: This will delete ALL data!")
 
-    Args:
-        db: Database session
-        auth_manager: AuthManager instance for password hashing
+    # Order matters due to foreign key constraints
+    tables_to_clear = [
+        OrderItem,
+        Order,
+        CustomerAddress,
+        Customer,
+        Product,
+        MarketplaceProduct,
+        MarketplaceImportJob,
+        VendorUser,
+        Role,
+        VendorDomain,
+        VendorTheme,
+        Vendor,
+        AdminSetting,
+        PlatformAlert,
+        User,
+    ]
 
-    Returns:
-        tuple: (User object, was_created boolean)
-    """
-    # Check if admin already exists
-    existing_admin = db.execute(
-        select(User).where(User.username == DEFAULT_ADMIN_USERNAME)
+    try:
+        for model in tables_to_clear:
+            count = db.query(model).count()
+            if count > 0:
+                db.execute(delete(model))
+                print_info(f"Deleted {count} records from {model.__tablename__}")
+
+        db.commit()
+        print_success("Database reset complete")
+
+    except Exception as e:
+        db.rollback()
+        print_error(f"Failed to reset database: {e}")
+        raise
+
+
+# =============================================================================
+# SEEDING FUNCTIONS
+# =============================================================================
+
+def create_user(
+        db: Session,
+        auth_manager: AuthManager,
+        username: str,
+        email: str,
+        password: str,
+        role: str = "user",
+        first_name: str = None,
+        last_name: str = None,
+) -> Tuple[User, bool]:
+    """Create user if it doesn't exist."""
+
+    existing_user = db.execute(
+        select(User).where(User.username == username)
     ).scalar_one_or_none()
 
-    if existing_admin:
-        return existing_admin, False
+    if existing_user:
+        return existing_user, False
 
-    # Create new admin user
-    admin = User(
-        email=DEFAULT_ADMIN_EMAIL,
-        username=DEFAULT_ADMIN_USERNAME,
-        hashed_password=auth_manager.hash_password(DEFAULT_ADMIN_PASSWORD),
-        role="admin",
+    user = User(
+        email=email,
+        username=username,
+        hashed_password=auth_manager.hash_password(password),
+        role=role,
+        first_name=first_name,
+        last_name=last_name,
         is_active=True,
         created_at=datetime.now(timezone.utc),
         updated_at=datetime.now(timezone.utc)
     )
 
-    db.add(admin)
-    db.flush()  # Get the ID
+    db.add(user)
+    db.flush()
 
-    return admin, True
+    return user, True
 
 
 def create_vendor(
@@ -105,23 +399,10 @@ def create_vendor(
         name: str,
         subdomain: str,
         owner_user_id: int,
-        description: str = None
-) -> tuple[Vendor, bool]:
-    """
-    Create vendor if it doesn't exist.
+        description: str = None,
+) -> Tuple[Vendor, bool]:
+    """Create vendor if it doesn't exist."""
 
-    Args:
-        db: Database session
-        vendor_code: Unique vendor code
-        name: Vendor name
-        subdomain: Subdomain for the vendor
-        owner_user_id: ID of the owner user
-        description: Optional description
-
-    Returns:
-        tuple: (Vendor object, was_created boolean)
-    """
-    # Check if vendor already exists
     existing_vendor = db.execute(
         select(Vendor).where(Vendor.vendor_code == vendor_code)
     ).scalar_one_or_none()
@@ -129,12 +410,11 @@ def create_vendor(
     if existing_vendor:
         return existing_vendor, False
 
-    # Create new vendor
     vendor = Vendor(
         vendor_code=vendor_code,
         subdomain=subdomain,
         name=name,
-        description=description or f"{name} - Development vendor",
+        description=description or f"{name} - Online marketplace",
         owner_user_id=owner_user_id,
         contact_email=f"contact@{subdomain}.com",
         contact_phone="+352 123 456 789",
@@ -151,155 +431,912 @@ def create_vendor(
     return vendor, True
 
 
-def seed_database():
-    """Main seeding function."""
+def create_vendor_theme(
+        db: Session,
+        vendor_id: int,
+        theme_preset: str = "default",
+) -> Tuple[VendorTheme, bool]:
+    """Create vendor theme if it doesn't exist."""
+
+    existing_theme = db.execute(
+        select(VendorTheme).where(VendorTheme.vendor_id == vendor_id)
+    ).scalar_one_or_none()
+
+    if existing_theme:
+        return existing_theme, False
+
+    preset = THEME_PRESETS.get(theme_preset, THEME_PRESETS["default"])
+
+    theme = VendorTheme(
+        vendor_id=vendor_id,
+        theme_name=preset["theme_name"],
+        is_active=True,
+        colors=preset["colors"],
+        font_family_heading=preset["font_family_heading"],
+        font_family_body=preset["font_family_body"],
+        layout_style=preset["layout_style"],
+        header_style=preset["header_style"],
+        product_card_style=preset["product_card_style"],
+        social_links={
+            "facebook": f"https://facebook.com/vendor{vendor_id}",
+            "instagram": f"https://instagram.com/vendor{vendor_id}",
+            "twitter": f"https://twitter.com/vendor{vendor_id}",
+        },
+        created_at=datetime.now(timezone.utc),
+        updated_at=datetime.now(timezone.utc)
+    )
+
+    db.add(theme)
+    db.flush()
+
+    return theme, True
+
+
+def create_vendor_domain(
+        db: Session,
+        vendor_id: int,
+        domain: str,
+        is_primary: bool = False,
+) -> Tuple[VendorDomain, bool]:
+    """Create vendor custom domain if it doesn't exist."""
+
+    normalized_domain = VendorDomain.normalize_domain(domain)
+
+    existing_domain = db.execute(
+        select(VendorDomain).where(VendorDomain.domain == normalized_domain)
+    ).scalar_one_or_none()
+
+    if existing_domain:
+        return existing_domain, False
+
+    vendor_domain = VendorDomain(
+        vendor_id=vendor_id,
+        domain=normalized_domain,
+        is_primary=is_primary,
+        is_active=True,
+        ssl_status="pending",
+        is_verified=False,
+        verification_token=f"verify_{vendor_id}_{normalized_domain.replace('.', '_')}",
+        created_at=datetime.now(timezone.utc),
+        updated_at=datetime.now(timezone.utc)
+    )
+
+    db.add(vendor_domain)
+    db.flush()
+
+    return vendor_domain, True
+
+
+def create_marketplace_product(
+        db: Session,
+        product_data: Dict,
+        marketplace: str = "Wizamart",
+        vendor_name: str = None,
+) -> Tuple[MarketplaceProduct, bool]:
+    """Create marketplace product if it doesn't exist."""
+
+    existing_product = db.execute(
+        select(MarketplaceProduct).where(
+            MarketplaceProduct.marketplace_product_id == product_data["marketplace_product_id"]
+        )
+    ).scalar_one_or_none()
+
+    if existing_product:
+        return existing_product, False
+
+    mp_product = MarketplaceProduct(
+        marketplace_product_id=product_data["marketplace_product_id"],
+        title=product_data["title"],
+        description=product_data.get("description"),
+        price=product_data.get("price"),
+        brand=product_data.get("brand"),
+        gtin=product_data.get("gtin"),
+        availability=product_data.get("availability", "in stock"),
+        condition=product_data.get("condition", "new"),
+        google_product_category=product_data.get("google_product_category"),
+        marketplace=marketplace,
+        vendor_name=vendor_name,
+        currency="EUR",
+        created_at=datetime.now(timezone.utc),
+        updated_at=datetime.now(timezone.utc)
+    )
+
+    db.add(mp_product)
+    db.flush()
+
+    return mp_product, True
+
+
+def create_vendor_product(
+        db: Session,
+        vendor_id: int,
+        marketplace_product_id: int,
+        product_id: str = None,
+        price: float = None,
+        is_featured: bool = False,
+) -> Tuple[Product, bool]:
+    """Create vendor product (links vendor to marketplace product)."""
+
+    existing_product = db.execute(
+        select(Product).where(
+            Product.vendor_id == vendor_id,
+            Product.marketplace_product_id == marketplace_product_id
+        )
+    ).scalar_one_or_none()
+
+    if existing_product:
+        return existing_product, False
+
+    product = Product(
+        vendor_id=vendor_id,
+        marketplace_product_id=marketplace_product_id,
+        product_id=product_id,
+        price=price,
+        currency="EUR",
+        availability="in stock",
+        condition="new",
+        is_featured=is_featured,
+        is_active=True,
+        display_order=0,
+        min_quantity=1,
+        created_at=datetime.now(timezone.utc),
+        updated_at=datetime.now(timezone.utc)
+    )
+
+    db.add(product)
+    db.flush()
+
+    return product, True
+
+
+def create_customer(
+        db: Session,
+        auth_manager: AuthManager,
+        vendor_id: int,
+        email: str,
+        password: str,
+        first_name: str,
+        last_name: str,
+        customer_number: str,
+) -> Tuple[Customer, bool]:
+    """Create customer for a vendor."""
+
+    existing_customer = db.execute(
+        select(Customer).where(
+            Customer.vendor_id == vendor_id,
+            Customer.email == email
+        )
+    ).scalar_one_or_none()
+
+    if existing_customer:
+        return existing_customer, False
+
+    customer = Customer(
+        vendor_id=vendor_id,
+        email=email,
+        hashed_password=auth_manager.hash_password(password),
+        first_name=first_name,
+        last_name=last_name,
+        phone="+352 99 123 456",
+        customer_number=customer_number,
+        is_active=True,
+        total_orders=0,
+        total_spent=Decimal("0.00"),
+        marketing_consent=True,
+        created_at=datetime.now(timezone.utc),
+        updated_at=datetime.now(timezone.utc)
+    )
+
+    db.add(customer)
+    db.flush()
+
+    return customer, True
+
+
+def create_customer_address(
+        db: Session,
+        vendor_id: int,
+        customer_id: int,
+        address_type: str,
+        is_default: bool = False,
+) -> Tuple[CustomerAddress, bool]:
+    """Create customer address."""
+
+    existing_address = db.execute(
+        select(CustomerAddress).where(
+            CustomerAddress.customer_id == customer_id,
+            CustomerAddress.address_type == address_type
+        )
+    ).scalar_one_or_none()
+
+    if existing_address:
+        return existing_address, False
+
+    address = CustomerAddress(
+        vendor_id=vendor_id,
+        customer_id=customer_id,
+        address_type=address_type,
+        first_name="John",
+        last_name="Doe",
+        company="ACME Corp" if address_type == "billing" else None,
+        address_line_1="123 Main Street",
+        address_line_2="Apt 4B",
+        city="Luxembourg",
+        postal_code="L-1234",
+        country="Luxembourg",
+        is_default=is_default,
+        created_at=datetime.now(timezone.utc),
+        updated_at=datetime.now(timezone.utc)
+    )
+
+    db.add(address)
+    db.flush()
+
+    return address, True
+
+
+def create_order(
+        db: Session,
+        vendor_id: int,
+        customer_id: int,
+        order_number: str,
+        products: List[Tuple[int, int, float]],  # (product_id, quantity, price)
+        shipping_address_id: int,
+        billing_address_id: int,
+        status: str = "pending",
+) -> Tuple[Order, bool]:
+    """Create order with items."""
+
+    existing_order = db.execute(
+        select(Order).where(Order.order_number == order_number)
+    ).scalar_one_or_none()
+
+    if existing_order:
+        return existing_order, False
+
+    # Calculate totals
+    subtotal = sum(qty * price for _, qty, price in products)
+    tax_amount = subtotal * 0.17  # 17% VAT
+    shipping_amount = 9.99 if subtotal < 50 else 0.0
+    total_amount = subtotal + tax_amount + shipping_amount
+
+    order = Order(
+        vendor_id=vendor_id,
+        customer_id=customer_id,
+        order_number=order_number,
+        status=status,
+        subtotal=subtotal,
+        tax_amount=tax_amount,
+        shipping_amount=shipping_amount,
+        discount_amount=0.0,
+        total_amount=total_amount,
+        currency="EUR",
+        shipping_address_id=shipping_address_id,
+        billing_address_id=billing_address_id,
+        shipping_method="Standard Shipping",
+        created_at=datetime.now(timezone.utc),
+        updated_at=datetime.now(timezone.utc)
+    )
+
+    db.add(order)
+    db.flush()
+
+    # Create order items
+    for product_id, quantity, unit_price in products:
+        order_item = OrderItem(
+            order_id=order.id,
+            product_id=product_id,
+            product_name=f"Product {product_id}",
+            product_sku=f"SKU-{product_id}",
+            quantity=quantity,
+            unit_price=unit_price,
+            total_price=quantity * unit_price,
+            inventory_reserved=True,
+            inventory_fulfilled=False,
+            created_at=datetime.now(timezone.utc),
+            updated_at=datetime.now(timezone.utc)
+        )
+        db.add(order_item)
+
+    db.flush()
+    return order, True
+
+
+def create_import_job(
+        db: Session,
+        vendor_id: int,
+        user_id: int,
+        marketplace: str,
+        status: str = "completed",
+        imported_count: int = 5,
+) -> Tuple[MarketplaceImportJob, bool]:
+    """Create import job."""
+
+    job = MarketplaceImportJob(
+        vendor_id=vendor_id,
+        user_id=user_id,
+        marketplace=marketplace,
+        source_url=f"https://{marketplace.lower()}.com/feed.xml",
+        status=status,
+        imported_count=imported_count,
+        updated_count=0,
+        error_count=0,
+        total_processed=imported_count,
+        started_at=datetime.now(timezone.utc) - timedelta(hours=1),
+        completed_at=datetime.now(timezone.utc),
+        created_at=datetime.now(timezone.utc),
+        updated_at=datetime.now(timezone.utc)
+    )
+
+    db.add(job)
+    db.flush()
+
+    return job, True
+
+
+def create_admin_settings(db: Session) -> List[AdminSetting]:
+    """Create platform admin settings."""
+
+    settings = [
+        {
+            "key": "max_vendors_allowed",
+            "value": "1000",
+            "value_type": "integer",
+            "category": "system",
+            "description": "Maximum number of vendors allowed on the platform",
+        },
+        {
+            "key": "maintenance_mode",
+            "value": "false",
+            "value_type": "boolean",
+            "category": "system",
+            "description": "Enable maintenance mode to prevent access",
+        },
+        {
+            "key": "default_vendor_trial_days",
+            "value": "30",
+            "value_type": "integer",
+            "category": "marketplace",
+            "description": "Default trial period for new vendors in days",
+        },
+        {
+            "key": "platform_commission_rate",
+            "value": "0.05",
+            "value_type": "float",
+            "category": "marketplace",
+            "description": "Platform commission rate (5%)",
+        },
+    ]
+
+    created_settings = []
+
+    for setting_data in settings:
+        existing_setting = db.execute(
+            select(AdminSetting).where(AdminSetting.key == setting_data["key"])
+        ).scalar_one_or_none()
+
+        if not existing_setting:
+            setting = AdminSetting(
+                key=setting_data["key"],
+                value=setting_data["value"],
+                value_type=setting_data["value_type"],
+                category=setting_data["category"],
+                description=setting_data["description"],
+                is_encrypted=False,
+                is_public=False,
+                created_at=datetime.now(timezone.utc),
+                updated_at=datetime.now(timezone.utc)
+            )
+            db.add(setting)
+            created_settings.append(setting)
+
+    db.flush()
+    return created_settings
+
+
+def create_platform_alerts(db: Session) -> List[PlatformAlert]:
+    """Create sample platform alerts."""
+
+    alerts = [
+        {
+            "alert_type": "performance",
+            "severity": "info",
+            "title": "High Traffic Detected",
+            "description": "Platform experiencing higher than normal traffic",
+            "is_resolved": True,
+            "resolved_at": datetime.now(timezone.utc) - timedelta(hours=2),
+        },
+        {
+            "alert_type": "security",
+            "severity": "warning",
+            "title": "Multiple Failed Login Attempts",
+            "description": "Detected multiple failed login attempts from IP 192.168.1.100",
+            "is_resolved": False,
+        },
+    ]
+
+    created_alerts = []
+
+    for alert_data in alerts:
+        alert = PlatformAlert(
+            alert_type=alert_data["alert_type"],
+            severity=alert_data["severity"],
+            title=alert_data["title"],
+            description=alert_data["description"],
+            is_resolved=alert_data["is_resolved"],
+            resolved_at=alert_data.get("resolved_at"),
+            auto_generated=True,
+            occurrence_count=1,
+            first_occurred_at=datetime.now(timezone.utc) - timedelta(hours=3),
+            last_occurred_at=datetime.now(timezone.utc),
+            created_at=datetime.now(timezone.utc),
+            updated_at=datetime.now(timezone.utc)
+        )
+        db.add(alert)
+        created_alerts.append(alert)
+
+    db.flush()
+    return created_alerts
+
+
+# =============================================================================
+# MAIN SEEDING LOGIC
+# =============================================================================
+
+def seed_minimal(db: Session, auth_manager: AuthManager):
+    """Seed minimal data (admin + 1 vendor)."""
+
+    print_section("MINIMAL SEEDING")
+
+    # Create admin user
+    print_step(1, "Creating admin user...")
+    admin, admin_created = create_user(
+        db, auth_manager,
+        username=DEFAULT_ADMIN_USERNAME,
+        email=DEFAULT_ADMIN_EMAIL,
+        password=DEFAULT_ADMIN_PASSWORD,
+        role="admin"
+    )
+
+    if admin_created:
+        print_success(f"Admin user created (ID: {admin.id})")
+    else:
+        print_info(f"Admin user already exists (ID: {admin.id})")
+
+    # Create WizaMart vendor
+    print_step(2, "Creating WizaMart vendor...")
+    vendor, vendor_created = create_vendor(
+        db,
+        vendor_code="WIZAMART",
+        name="WizaMart",
+        subdomain="wizamart",
+        owner_user_id=admin.id,
+        description="Premium electronics marketplace"
+    )
+
+    if vendor_created:
+        print_success(f"WizaMart created (ID: {vendor.id})")
+    else:
+        print_info(f"WizaMart already exists (ID: {vendor.id})")
+
+    db.commit()
+    print_success("Minimal seeding complete")
+
+
+def seed_full(db: Session, auth_manager: AuthManager):
+    """Seed comprehensive test data."""
+
+    print_section("COMPREHENSIVE SEEDING")
+
+    # =========================================================================
+    # STEP 1: CREATE USERS
+    # =========================================================================
+
+    print_step(1, "Creating users...")
+
+    # Create admin
+    admin, admin_created = create_user(
+        db, auth_manager,
+        username=DEFAULT_ADMIN_USERNAME,
+        email=DEFAULT_ADMIN_EMAIL,
+        password=DEFAULT_ADMIN_PASSWORD,
+        role="admin"
+    )
+
+    if admin_created:
+        print_success(f"Admin user created (ID: {admin.id})")
+    else:
+        print_info(f"Admin user already exists (ID: {admin.id})")
+
+    # Create test users
+    test_users_created = []
+    for user_data in TEST_USERS:
+        user, created = create_user(
+            db, auth_manager,
+            username=user_data["username"],
+            email=user_data["email"],
+            password=user_data["password"],
+            role=user_data["role"],
+            first_name=user_data.get("first_name"),
+            last_name=user_data.get("last_name"),
+        )
+        if created:
+            test_users_created.append(user)
+            print_success(f"User '{user.username}' created (ID: {user.id})")
+
+    if not test_users_created:
+        print_info("All test users already exist")
+
+    # =========================================================================
+    # STEP 2: CREATE VENDORS
+    # =========================================================================
+
+    print_step(2, "Creating vendors...")
+
+    vendors = []
+    for config in VENDOR_CONFIGS:
+        vendor, created = create_vendor(
+            db,
+            vendor_code=config["vendor_code"],
+            name=config["name"],
+            subdomain=config["subdomain"],
+            owner_user_id=admin.id,
+            description=config["description"]
+        )
+        vendors.append(vendor)
+
+        if created:
+            print_success(f"{config['vendor_code']} created (ID: {vendor.id})")
+
+            # Create vendor theme
+            theme, theme_created = create_vendor_theme(
+                db,
+                vendor_id=vendor.id,
+                theme_preset=config.get("theme_preset", "default")
+            )
+            if theme_created:
+                print_success(f"  Theme '{theme.theme_name}' applied")
+
+            # Create custom domain if specified
+            if config.get("custom_domain"):
+                domain, domain_created = create_vendor_domain(
+                    db,
+                    vendor_id=vendor.id,
+                    domain=config["custom_domain"],
+                    is_primary=True
+                )
+                if domain_created:
+                    print_success(f"  Custom domain '{domain.domain}' added")
+        else:
+            print_info(f"{config['vendor_code']} already exists (ID: {vendor.id})")
+
+    # =========================================================================
+    # STEP 3: CREATE PRODUCTS
+    # =========================================================================
+
+    print_step(3, "Creating products...")
+
+    products_created = 0
+    vendor_products = []
+
+    for product_data in SAMPLE_PRODUCTS:
+        # Create marketplace product
+        mp_product, created = create_marketplace_product(
+            db,
+            product_data=product_data,
+            marketplace="Wizamart",
+            vendor_name=vendors[0].name
+        )
+
+        if created:
+            products_created += 1
+
+        # Link to first two vendors
+        for vendor in vendors[:2]:
+            vendor_product, vp_created = create_vendor_product(
+                db,
+                vendor_id=vendor.id,
+                marketplace_product_id=mp_product.id,
+                product_id=f"{vendor.vendor_code}-{product_data['marketplace_product_id']}",
+                price=float(product_data["price"]),
+                is_featured=(products_created <= 2)
+            )
+            if vp_created:
+                vendor_products.append(vendor_product)
+
+    print_success(f"Created {products_created} marketplace products")
+    print_success(f"Created {len(vendor_products)} vendor product links")
+
+    # =========================================================================
+    # STEP 4: CREATE CUSTOMERS
+    # =========================================================================
+
+    print_step(4, "Creating customers...")
+
+    customers_created = 0
+    addresses_created = 0
+
+    for i, vendor in enumerate(vendors[:2]):
+        # Create 2 customers per vendor
+        for j in range(1, 3):
+            customer, created = create_customer(
+                db,
+                auth_manager,
+                vendor_id=vendor.id,
+                email=f"customer{i + 1}{j}@example.com",
+                password="password123",
+                first_name=f"Customer{i + 1}{j}",
+                last_name="Buyer",
+                customer_number=f"{vendor.vendor_code}-CUST-{j:04d}"
+            )
+
+            if created:
+                customers_created += 1
+
+                # Create addresses
+                shipping_addr, _ = create_customer_address(
+                    db, vendor.id, customer.id, "shipping", is_default=True
+                )
+                billing_addr, _ = create_customer_address(
+                    db, vendor.id, customer.id, "billing", is_default=True
+                )
+                addresses_created += 2
+
+    print_success(f"Created {customers_created} customers")
+    print_success(f"Created {addresses_created} addresses")
+
+    # =========================================================================
+    # STEP 5: CREATE ORDERS
+    # =========================================================================
+
+    print_step(5, "Creating orders...")
+
+    orders_created = 0
+
+    # Get customers for first vendor
+    vendor = vendors[0]
+    vendor_customers = db.execute(
+        select(Customer).where(Customer.vendor_id == vendor.id)
+    ).scalars().all()
+
+    vendor_product_list = [vp for vp in vendor_products if vp.vendor_id == vendor.id]
+
+    if vendor_customers and vendor_product_list:
+        for i, customer in enumerate(vendor_customers[:2]):
+            # Get customer addresses
+            addresses = db.execute(
+                select(CustomerAddress).where(CustomerAddress.customer_id == customer.id)
+            ).scalars().all()
+
+            if len(addresses) >= 2:
+                shipping_addr = next(a for a in addresses if a.address_type == "shipping")
+                billing_addr = next(a for a in addresses if a.address_type == "billing")
+
+                # Create order with 2 products
+                products_for_order = [
+                    (vendor_product_list[0].id, 1, 149.99),
+                    (vendor_product_list[1].id, 2, 79.99),
+                ]
+
+                order, created = create_order(
+                    db,
+                    vendor_id=vendor.id,
+                    customer_id=customer.id,
+                    order_number=f"ORD-{vendor.vendor_code}-{i + 1:05d}",
+                    products=products_for_order,
+                    shipping_address_id=shipping_addr.id,
+                    billing_address_id=billing_addr.id,
+                    status="completed" if i == 0 else "processing"
+                )
+
+                if created:
+                    orders_created += 1
+
+    print_success(f"Created {orders_created} orders")
+
+    # =========================================================================
+    # STEP 6: CREATE IMPORT JOBS
+    # =========================================================================
+
+    print_step(6, "Creating import jobs...")
+
+    jobs_created = 0
+
+    for vendor in vendors[:2]:
+        job, created = create_import_job(
+            db,
+            vendor_id=vendor.id,
+            user_id=admin.id,
+            marketplace="Wizamart",
+            status="completed",
+            imported_count=len(SAMPLE_PRODUCTS)
+        )
+        if created:
+            jobs_created += 1
+
+    print_success(f"Created {jobs_created} import jobs")
+
+    # =========================================================================
+    # STEP 7: CREATE ADMIN DATA
+    # =========================================================================
+
+    print_step(7, "Creating admin settings and alerts...")
+
+    settings = create_admin_settings(db)
+    alerts = create_platform_alerts(db)
+
+    print_success(f"Created {len(settings)} admin settings")
+    print_success(f"Created {len(alerts)} platform alerts")
+
+    # =========================================================================
+    # COMMIT ALL CHANGES
+    # =========================================================================
+
+    db.commit()
+    print_success("All data committed successfully")
+
+
+def print_summary(db: Session):
+    """Print summary of seeded data."""
+
+    print_section("SEEDING SUMMARY")
+
+    # Count records
+    user_count = db.query(User).count()
+    vendor_count = db.query(Vendor).count()
+    theme_count = db.query(VendorTheme).count()
+    domain_count = db.query(VendorDomain).count()
+    mp_product_count = db.query(MarketplaceProduct).count()
+    product_count = db.query(Product).count()
+    customer_count = db.query(Customer).count()
+    address_count = db.query(CustomerAddress).count()
+    order_count = db.query(Order).count()
+    order_item_count = db.query(OrderItem).count()
+    import_job_count = db.query(MarketplaceImportJob).count()
+    setting_count = db.query(AdminSetting).count()
+    alert_count = db.query(PlatformAlert).count()
+
+    print(f"📊 Database Statistics:")
+    print(f"  Users:               {user_count}")
+    print(f"  Vendors:             {vendor_count}")
+    print(f"  Vendor Themes:       {theme_count}")
+    print(f"  Custom Domains:      {domain_count}")
+    print(f"  Marketplace Products: {mp_product_count}")
+    print(f"  Vendor Products:     {product_count}")
+    print(f"  Customers:           {customer_count}")
+    print(f"  Addresses:           {address_count}")
+    print(f"  Orders:              {order_count}")
+    print(f"  Order Items:         {order_item_count}")
+    print(f"  Import Jobs:         {import_job_count}")
+    print(f"  Admin Settings:      {setting_count}")
+    print(f"  Platform Alerts:     {alert_count}")
+
+    print("\n" + "─" * 70)
+    print("🔐 ADMIN LOGIN CREDENTIALS")
+    print("─" * 70)
+    print(f"  URL:      http://localhost:8000/admin/login")
+    print(f"  Username: {DEFAULT_ADMIN_USERNAME}")
+    print(f"  Password: {DEFAULT_ADMIN_PASSWORD}")
+    print("─" * 70)
+
+    print("\n" + "─" * 70)
+    print("🏪 VENDORS")
+    print("─" * 70)
+
+    vendors = db.execute(select(Vendor)).scalars().all()
+    for vendor in vendors:
+        print(f"\n  {vendor.vendor_code}")
+        print(f"    Name:       {vendor.name}")
+        print(f"    Subdomain:  {vendor.subdomain}")
+
+        if vendor.vendor_theme:
+            print(f"    Theme:      {vendor.vendor_theme.theme_name}")
+
+        custom_domains = [d for d in vendor.domains if d.is_active]
+        if custom_domains:
+            print(f"    Domains:    {', '.join(d.domain for d in custom_domains)}")
+
+        product_count = db.query(Product).filter(Product.vendor_id == vendor.id).count()
+        print(f"    Products:   {product_count}")
+
+        customer_count = db.query(Customer).filter(Customer.vendor_id == vendor.id).count()
+        print(f"    Customers:  {customer_count}")
+
+    print("\n" + "─" * 70)
+    print("🚀 NEXT STEPS")
+    print("─" * 70)
+    print("  1. Start the server:")
+    print("     make dev")
+    print()
+    print("  2. Login to admin panel:")
+    print("     http://localhost:8000/admin/login")
+    print()
+    print("  3. Test vendor shops:")
+    for vendor in vendors[:3]:
+        print(f"     http://localhost:8000/shop/{vendor.vendor_code}")
+    print()
+    print("⚠️  SECURITY: Change default passwords in production!")
+    print()
+
+
+# =============================================================================
+# MAIN ENTRY POINT
+# =============================================================================
+
+def main():
+    """Main entry point for database seeding."""
+
+    parser = argparse.ArgumentParser(
+        description="Seed Wizamart database with test data"
+    )
+    parser.add_argument(
+        "--reset",
+        action="store_true",
+        help="Reset database before seeding (destructive!)"
+    )
+    parser.add_argument(
+        "--minimal",
+        action="store_true",
+        help="Create only minimal data (admin + 1 vendor)"
+    )
+
+    args = parser.parse_args()
 
     print("\n" + "╔" + "═" * 68 + "╗")
-    print("║" + " " * 18 + "DATABASE SEEDING SCRIPT" + " " * 27 + "║")
+    print("║" + " " * 18 + "WIZAMART DATABASE SEEDER" + " " * 26 + "║")
     print("╚" + "═" * 68 + "╝\n")
 
-    # ========================================================================
-    # STEP 1: VERIFY DATABASE
-    # ========================================================================
+    # =========================================================================
+    # VERIFY DATABASE
+    # =========================================================================
 
-    print("STEP 1: Verifying database...")
+    print_step(1, "Verifying database...")
 
     if not verify_database_ready():
-        print("\n❌ ERROR: Database not ready!")
-        print("\n   Required tables don't exist yet.")
-        print("   Please run database migrations first:\n")
-        print("   alembic upgrade head\n")
+        print_error("Database not ready!")
+        print("\nRequired tables don't exist. Run migrations first:")
+        print("  make migrate-up\n")
         sys.exit(1)
 
-    print("  ✓ Database tables verified\n")
+    print_success("Database tables verified")
 
-    # ========================================================================
-    # STEP 2: CREATE ADMIN USER
-    # ========================================================================
+    # =========================================================================
+    # SEED DATA
+    # =========================================================================
 
     db = SessionLocal()
     auth_manager = AuthManager()
 
     try:
-        print("STEP 2: Creating admin user...")
+        # Reset database if requested
+        if args.reset:
+            confirm = input("\n⚠️  Are you sure you want to DELETE ALL DATA? (type 'yes' to confirm): ")
+            if confirm.lower() == 'yes':
+                reset_database(db)
+            else:
+                print("Reset cancelled.")
+                return
 
-        admin, admin_created = create_admin_user(db, auth_manager)
-
-        if admin_created:
-            print(f"  ✓ Admin user created (ID: {admin.id})")
-            print(f"    Username: {admin.username}")
-            print(f"    Email: {admin.email}")
+        # Seed data
+        if args.minimal:
+            seed_minimal(db, auth_manager)
         else:
-            print(f"  ℹ️  Admin user already exists (ID: {admin.id})")
-            print(f"    Username: {admin.username}")
-            print(f"    Email: {admin.email}")
+            seed_full(db, auth_manager)
 
-        # ====================================================================
-        # STEP 3: CREATE VENDORS
-        # ====================================================================
+        # Print summary
+        print_summary(db)
 
-        print("\nSTEP 3: Creating vendors...")
+        print_section("✅ SEEDING COMPLETED SUCCESSFULLY!", "=")
 
-        # Create TESTVENDOR
-        test_vendor, test_created = create_vendor(
-            db,
-            vendor_code="TESTVENDOR",
-            name="Test Vendor",
-            subdomain="testvendor",
-            owner_user_id=admin.id,
-            description="Development test vendor for general testing"
-        )
-
-        if test_created:
-            print(f"  ✓ TESTVENDOR created (ID: {test_vendor.id})")
-        else:
-            print(f"  ℹ️  TESTVENDOR already exists (ID: {test_vendor.id})")
-
-        # Create WIZAMART
-        wizamart, wizamart_created = create_vendor(
-            db,
-            vendor_code="WIZAMART",
-            name="WizaMart",
-            subdomain="wizamart",
-            owner_user_id=admin.id,
-            description="Primary development vendor for theme customization"
-        )
-
-        if wizamart_created:
-            print(f"  ✓ WIZAMART created (ID: {wizamart.id})")
-        else:
-            print(f"  ℹ️  WIZAMART already exists (ID: {wizamart.id})")
-
-        # Commit all changes
-        db.commit()
-
-        # ====================================================================
-        # SUMMARY
-        # ====================================================================
-
-        print("\n" + "╔" + "═" * 68 + "╗")
-        print("║" + " " * 22 + "SEEDING COMPLETE!" + " " * 28 + "║")
-        print("╚" + "═" * 68 + "╝\n")
-
-        if admin_created or test_created or wizamart_created:
-            print("✅ New items created:")
-            if admin_created:
-                print("  • Admin user")
-            if test_created:
-                print("  • TESTVENDOR")
-            if wizamart_created:
-                print("  • WIZAMART")
-        else:
-            print("ℹ️  All items already existed - no changes made")
-
-        print("\n" + "─" * 70)
-        print("📝 ADMIN LOGIN CREDENTIALS")
-        print("─" * 70)
-        print(f"  URL:      http://localhost:8000/admin/login")
-        print(f"  Username: {DEFAULT_ADMIN_USERNAME}")
-        print(f"  Password: {DEFAULT_ADMIN_PASSWORD}")
-        print("─" * 70)
-
-        print("\n" + "─" * 70)
-        print("🏪 VENDORS")
-        print("─" * 70)
-
-        vendors = db.execute(select(Vendor)).scalars().all()
-        for v in vendors:
-            print(f"\n  {v.vendor_code}")
-            print(f"    Name:       {v.name}")
-            print(f"    Subdomain:  {v.subdomain}.wizamart.com")
-            print(f"    Theme URL:  http://localhost:8000/admin/vendors/{v.vendor_code}/theme")
-            print(f"    Verified:   {'✓' if v.is_verified else '✗'}")
-            print(f"    Active:     {'✓' if v.is_active else '✗'}")
-
-        print("\n" + "─" * 70)
-        print("🚀 NEXT STEPS")
-        print("─" * 70)
-        print("  1. Start the server:")
-        print("     python -m uvicorn app.main:app --reload\n")
-        print("  2. Login to admin panel:")
-        print("     http://localhost:8000/admin/login\n")
-        print("  3. Test theme editor:")
-        print("     http://localhost:8000/admin/vendors/WIZAMART/theme\n")
-
-        if admin_created:
-            print("⚠️  SECURITY: Change the default admin password after first login!")
-
-        print()
+    except KeyboardInterrupt:
+        db.rollback()
+        print("\n\n⚠️  Seeding interrupted by user")
+        sys.exit(1)
 
     except Exception as e:
         db.rollback()
-        print("\n" + "╔" + "═" * 68 + "╗")
-        print("║" + " " * 28 + "ERROR" + " " * 35 + "║")
-        print("╚" + "═" * 68 + "╝\n")
-        print(f"❌ Failed to seed database: {e}")
-        print(f"\nError type: {type(e).__name__}")
-        print("\nCommon issues:")
-        print("  - Database migrations not run (run: alembic upgrade head)")
-        print("  - Database connection issues")
-        print("  - Foreign key constraint violations")
-        print()
+        print_section("❌ SEEDING FAILED", "!")
+        print(f"Error: {e}\n")
         import traceback
         traceback.print_exc()
         sys.exit(1)
@@ -309,11 +1346,4 @@ def seed_database():
 
 
 if __name__ == "__main__":
-    try:
-        seed_database()
-    except KeyboardInterrupt:
-        print("\n\n⚠️  Seeding interrupted by user")
-        sys.exit(1)
-    except Exception as e:
-        print(f"\n❌ Fatal error: {e}")
-        sys.exit(1)
+    main()