orion/app/api/v1/shop.py

import logging
from datetime import datetime
from typing import List, Optional

from fastapi import APIRouter, BackgroundTasks, Depends, HTTPException, Query
from sqlalchemy.orm import Session

from app.api.deps import get_current_user, get_user_shop
from app.core.database import get_db
from app.services.shop_service import shop_service
from app.tasks.background_tasks import process_marketplace_import
from middleware.decorators import rate_limit
from models.api_models import (MarketplaceImportJobResponse,
                               MarketplaceImportRequest, ShopCreate,
                               ShopListResponse, ShopProductCreate,
                               ShopProductResponse, ShopResponse)
from models.database_models import (MarketplaceImportJob, Product, Shop,
                                    ShopProduct, User)

router = APIRouter()
logger = logging.getLogger(__name__)


# Shop Management Routes
@router.post("/shop", response_model=ShopResponse)
def create_shop(
    shop_data: ShopCreate,
    db: Session = Depends(get_db),
    current_user: User = Depends(get_current_user),
):
    """Create a new shop (Protected)"""
    try:
        shop = shop_service.create_shop(
            db=db, shop_data=shop_data, current_user=current_user
        )
        return ShopResponse.model_validate(shop)
    except HTTPException:
        raise
    except Exception as e:
        logger.error(f"Error creating shop: {str(e)}")
        raise HTTPException(status_code=500, detail="Internal server error")


@router.get("/shop", response_model=ShopListResponse)
def get_shops(
    skip: int = Query(0, ge=0),
    limit: int = Query(100, ge=1, le=1000),
    active_only: bool = Query(True),
    verified_only: bool = Query(False),
    db: Session = Depends(get_db),
    current_user: User = Depends(get_current_user),
):
    """Get shops with filtering (Protected)"""
    try:
        shops, total = shop_service.get_shops(
            db=db,
            current_user=current_user,
            skip=skip,
            limit=limit,
            active_only=active_only,
            verified_only=verified_only,
        )

        return ShopListResponse(shops=shops, total=total, skip=skip, limit=limit)
    except HTTPException:
        raise
    except Exception as e:
        logger.error(f"Error getting shops: {str(e)}")
        raise HTTPException(status_code=500, detail="Internal server error")


@router.get("/shop/{shop_code}", response_model=ShopResponse)
def get_shop(
    shop_code: str,
    db: Session = Depends(get_db),
    current_user: User = Depends(get_current_user),
):
    """Get shop details (Protected)"""
    try:
        shop = shop_service.get_shop_by_code(
            db=db, shop_code=shop_code, current_user=current_user
        )
        return ShopResponse.model_validate(shop)
    except HTTPException:
        raise
    except Exception as e:
        logger.error(f"Error getting shop {shop_code}: {str(e)}")
        raise HTTPException(status_code=500, detail="Internal server error")


# Shop Product Management
@router.post("/shop/{shop_code}/products", response_model=ShopProductResponse)
def add_product_to_shop(
    shop_code: str,
    shop_product: ShopProductCreate,
    db: Session = Depends(get_db),
    current_user: User = Depends(get_current_user),
):
    """Add existing product to shop catalog with shop-specific settings (Protected)"""
    try:
        # Get and verify shop (using existing dependency)
        shop = get_user_shop(shop_code, current_user, db)

        # Add product to shop
        new_shop_product = shop_service.add_product_to_shop(
            db=db, shop=shop, shop_product=shop_product
        )

        # Return with product details
        response = ShopProductResponse.model_validate(new_shop_product)
        response.product = new_shop_product.product
        return response
    except HTTPException:
        raise
    except Exception as e:
        logger.error(f"Error adding product to shop {shop_code}: {str(e)}")
        raise HTTPException(status_code=500, detail="Internal server error")


@router.get("/shop/{shop_code}/products")
def get_shop_products(
    shop_code: str,
    skip: int = Query(0, ge=0),
    limit: int = Query(100, ge=1, le=1000),
    active_only: bool = Query(True),
    featured_only: bool = Query(False),
    db: Session = Depends(get_db),
    current_user: User = Depends(get_current_user),
):
    """Get products in shop catalog (Protected)"""
    try:
        # Get shop
        shop = shop_service.get_shop_by_code(
            db=db, shop_code=shop_code, current_user=current_user
        )

        # Get shop products
        shop_products, total = shop_service.get_shop_products(
            db=db,
            shop=shop,
            current_user=current_user,
            skip=skip,
            limit=limit,
            active_only=active_only,
            featured_only=featured_only,
        )

        # Format response
        products = []
        for sp in shop_products:
            product_response = ShopProductResponse.model_validate(sp)
            product_response.product = sp.product
            products.append(product_response)

        return {
            "products": products,
            "total": total,
            "skip": skip,
            "limit": limit,
            "shop": ShopResponse.model_validate(shop),
        }
    except HTTPException:
        raise
    except Exception as e:
        logger.error(f"Error getting products for shop {shop_code}: {str(e)}")
        raise HTTPException(status_code=500, detail="Internal server error")