from fastapi import APIRouter, Depends, HTTPException
from sqlalchemy.ext.asyncio import AsyncSession
from sqlalchemy import select
from datetime import datetime
from app.models.subscription_receipt import SubscriptionReceipt
from app.models.user import User
from app.db.session import get_db
from app.utils.responses import custom_response
from app.utils.helper import mask_email

import logging

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

def from_ms(ms: int) -> datetime:
    """Convert milliseconds to datetime"""
    return datetime.utcfromtimestamp(int(ms) / 1000)

async def verify_subscription(plans,latest_receipt,db,token_data,receipt,user_id=None):
    current_date = datetime.now().strftime("%Y-%m-%d %H:%M:%S")

    print('=====-=-=-=-=-=-=-=-=-=-==-=-',latest_receipt["original_transaction_id"])
    subscription_receipt = None
    criteria = {}
    criteria['subscriptionType'] = plans
    criteria['original_transaction_id'] = latest_receipt["original_transaction_id"]
    criteria['is_expired'] = False


    # Step 1: Look up by original_transaction_id (not expired)
    # criteria = (
    #     (SubscriptionReceipt.original_transaction_id == latest_receipt["original_transaction_id"]) &
    #     (SubscriptionReceipt.is_expired == False) #add in condition for ios_plans in sub types
    # )
    logger.warning(f"Criteria by original_transaction_id: {criteria}")

    print("Criteria by original_transaction_id: ",criteria)


    stmt = (
        select(SubscriptionReceipt)
        .where(
            SubscriptionReceipt.subscription_type.in_(criteria["subscriptionType"]),
            SubscriptionReceipt.original_transaction_id == criteria["original_transaction_id"],
            SubscriptionReceipt.is_expired == criteria["is_expired"],
        )
        .order_by(SubscriptionReceipt.id.desc())
    )

    result = await db.execute(stmt)
    subscription_receipt = result.scalars().first()


    print("Subscription Receipt after Step 1:", subscription_receipt)


    # Step 2: If not found, fallback to transaction_id
    if not subscription_receipt:
        criteria.pop("isExpired", None)

        # criteria = (
        #     (SubscriptionReceipt.transaction_id == latest_receipt["transaction_id"]) &
        #     (SubscriptionReceipt.original_transaction_id == latest_receipt["original_transaction_id"]) &
        #     (SubscriptionReceipt.is_expired == False) #add in condition for ios_plans in sub types
        # )
        logger.warning(f"Criteria by transaction_id: {criteria}")

        result = await db.execute(
            select(SubscriptionReceipt)
            .where(
                SubscriptionReceipt.subscription_type.in_(criteria["subscriptionType"]),
                SubscriptionReceipt.original_transaction_id == criteria["original_transaction_id"]
                )
            .order_by(SubscriptionReceipt.id.desc())
        )
        subscription_receipt = result.scalars().first()

        print("Subscription Receipt after Step 2:", subscription_receipt)
        
        if not subscription_receipt:

            result = await db.execute(
                select(SubscriptionReceipt)
                .where(
                        SubscriptionReceipt.subscription_type.in_(criteria["subscriptionType"]),
                        SubscriptionReceipt.original_transaction_id == criteria["original_transaction_id"],
                        SubscriptionReceipt.transaction_id == latest_receipt["transaction_id"],
                )
                .order_by(SubscriptionReceipt.id.desc())
            )
            subscription_receipt = result.scalars().first()

            print("Subscription Receipt after Step 3:", subscription_receipt)


    # Step 3: Check if already assigned to another active user
    if subscription_receipt and not subscription_receipt.is_expired:#false
        assigned_user_id = subscription_receipt.user_id #from recipt

        print('assigned_user_id==========',assigned_user_id)
        print("=========token_data.get('user_id')============",user_id)
        if subscription_receipt and subscription_receipt.user_id is None and subscription_receipt.user_device_id is not None:

            if user_id:
                subscription_receipt.user_id = user_id

            subscription_receipt.user_device_id = token_data["user_device_id"]

            db.add(subscription_receipt)
            await db.commit()
            await db.refresh(subscription_receipt)

            print("Updated subscription_receipt with user_device_id:", subscription_receipt.user_device_id)

        # You may need to fetch the User object if only user_id is stored
        # elif assigned_user_id != token_data.get('user_id'):#TOKEN data.user_id
        elif assigned_user_id != user_id:#TOKEN data.user_id
            assigned_user_result = await db.execute(
                select(User).where(User.user_id == assigned_user_id,User.is_deleted == 0)
            )
            assigned_user = assigned_user_result.scalars().first()
            email = assigned_user.email
            print("Assigned User:", assigned_user)
            email_text = email if email else "another account"
            email_text = mask_email(email_text)
            if assigned_user:
                logger.warning(f"This feature is linked to {email_text}."
                        f"To access Tattoo, please switch to the account originally used to enable this feature.")
                
                return {"code":403, "message":f"This feature is linked to {email_text}."
                        f"To access Tattoo, please switch to the account originally used to enable this feature."}
            else:
                return {"code":403, "message":f"Account deleted but receipt still assigned to {email_text}"}
        else:pass
            # logger.warning(f"Account deleted but receipt still assigned")
            # return {"code":403, "message":"Account deleted but receipt still assigned"}


    # criteria['user'] = token_data.get('user_id')
    criteria['user'] = user_id
    # Step 4: Look up by current user (resubscription case)
    print("Criteria by current user: ",criteria)
    print('=-=-=-=-=-=-=-latest_receipt["transaction_id"]',latest_receipt["transaction_id"])
    result = await db.execute(
            select(SubscriptionReceipt)
            .where(
                    SubscriptionReceipt.subscription_type.in_(criteria["subscriptionType"]),
                    SubscriptionReceipt.original_transaction_id == criteria["original_transaction_id"],
                    SubscriptionReceipt.transaction_id == latest_receipt["transaction_id"],
                    SubscriptionReceipt.user_id == criteria['user'],
            )
            .order_by(SubscriptionReceipt.id.desc())
        )
    subscription_receipt = result.scalars().first()

    print("Subscription Receipt after Step 4:", subscription_receipt)


    if subscription_receipt:
        logger.warning(f"SubscriptionReceipt Found: {subscription_receipt.id} : {user_id}")

        print('=====================into subscription_receipt')
        subscription_receipt.user_id = user_id,
        subscription_receipt.receipt = receipt
        subscription_receipt.transaction_id = latest_receipt["transaction_id"]
        subscription_receipt.original_transaction_id = latest_receipt["original_transaction_id"]
        subscription_receipt.subscription_date = from_ms(latest_receipt["purchase_date_ms"])
        subscription_receipt.is_trial_period = (latest_receipt.get("is_trial_period") == "true")
        subscription_receipt.subscription_type = latest_receipt["product_id"]
        subscription_receipt.expiry_date = from_ms(latest_receipt["expires_date_ms"])
        subscription_receipt.is_expired = False
        subscription_receipt.is_android = 1 if token_data.get("device_type") == "A" else 0
        subscription_receipt.modifiedDate = datetime.utcnow()

        await db.commit()

        # logger.debug(f"user {token_data.get('user_id')} is updated")
        logger.debug(f"user {user_id} is updated")

    else:
        # logger.warning(f"Creating new Subscription for user {token_data.get('user_id')}")
        logger.warning(f"Creating new Subscription for user {user_id}")

        print("======receipt=======",token_data.get('receipt'))
        print('ddddd',token_data.get("device_type"))
        subscription_receipt = SubscriptionReceipt(
            # user_id=token_data.get('user_id'),
            user_id=user_id,
            receipt=receipt,
            user_device_id=token_data.get('user_device_id'),
            transaction_id=latest_receipt["transaction_id"],
            original_transaction_id=latest_receipt["original_transaction_id"],
            subscription_date=from_ms(latest_receipt["purchase_date_ms"]),
            is_trial_period=(latest_receipt.get("is_trial_period") == "true"),
            subscription_type=latest_receipt["product_id"],
            expiry_date=from_ms(latest_receipt["expires_date_ms"]),
            is_expired=False,
            is_android=1 if token_data.get("device_type") == "A" else 0,
            createdDate=current_date,
            modifiedDate=current_date
            )
        
        try:
            db.add(subscription_receipt)
            await db.commit()
        except Exception as e:
            logger.error(f"Subscription Error: {str(e)}")
            raise HTTPException(status_code=500, detail="SOMETHING_WENT_WRONG")

    return {"code": 200, "message":"Subscription susccessfull","subscription_id": subscription_receipt.id}