import logging
from fastapi import APIRouter, Depends, Request
from sqlalchemy import update
from sqlalchemy.ext.asyncio import AsyncSession
from app.db.session import get_db
from app.models.user import User
from app.core.security import validate_token
from app.utils.responses import custom_response
from app.core.logging import logger
from app.models.generated_tattoo_history import GeneratedTattooHistory
from app.models.subscription_receipt import SubscriptionReceipt
import httpx
from app.core.rencryptor import encrypt_value, decrypt_value
import json
from app.core.config import settings

router = APIRouter()

APP_NAME = settings.APP_NAME

@router.post("/user/delete")
async def post_delete_user_account(
    request: Request,
    db: AsyncSession = Depends(get_db),
    token_data: dict = Depends(validate_token)
):
    """
    POST endpoint to delete user account (calls external DELETE API).
    """
    logger.info("Received request for /user/delete POST endpoint.")
    try:
        # Authorization check
        if token_data.get('code') != 200:
            logger.warning(f"Unauthorized access attempt to /user/delete. Message: {token_data.get('message', 'N/A')}")
            return custom_response(code=token_data.get('code', 500), message=token_data.get('message', 'Unauthorized'))

        print("Token data ==============:", token_data)
        user_id = token_data.get('user_id')
        deviceType = token_data.get('device_type')
        auth_key = token_data.get('auth_token')

        if not user_id:
            logger.warning("User ID not found in token for account delete request.")
            return custom_response(code=404, message="User not found or not authenticated")
        if not deviceType:
            logger.warning("Device type not found in token for account delete request.")
            return custom_response(code=400, message="Device type not found in token")
        if not auth_key:
            logger.warning("Auth key not found in token for account delete request.")
            return custom_response(code=400, message="Auth key not found in token")

        logger.info(f"Deleting account for user_id: {user_id}, deviceType: {deviceType}")

        # Call external DELETE API
        # external_url = "https://authservice.worksqr.com/api/v2/user"
        external_url = settings.DELETEUSER
        auth_key = encrypt_value(auth_key)
        headers = {
            "App": APP_NAME,
            "Auth-Key": auth_key,
            "Content-Type": "application/json"
        }
        async with httpx.AsyncClient() as client:
            response = await client.delete(external_url, headers=headers)
            data = decrypt_value(response.text)

            print("Response from external API:", type(json.loads(data)))

            decrypted_response =json.loads(data)
            logger.debug(f"Decrypted response from external API: {decrypted_response}")
            print("Decrypted response from external API:", decrypted_response) 
            if decrypted_response.get('code') == 200:
                # Update is_delete in User table
                stmt = (
                    update(User)
                    .where(User.user_id == user_id)
                    .values(is_deleted=1, fullname=None)
                )
                await db.execute(stmt)
                    # Update is_delete in GeneratedTattooHistory table
                history_stmt = (
                    update(GeneratedTattooHistory)
                    .where(GeneratedTattooHistory.user_id == user_id)
                    .values(is_delete=1)
                )
                await db.execute(history_stmt)

                stmt_subscription = (
                    update(SubscriptionReceipt)
                    .where(SubscriptionReceipt.user_id == user_id)
                    .values(user_id=None)
                )
                await db.execute(stmt_subscription)

                await db.commit()
                logger.info(f"Account deleted successfully for user_id: {user_id}")
                return custom_response(
                    code=200,
                    message="Account deleted successfully.",
                    data=None,
                    extra=None
                )
            else:
                logger.error(f"External API error: {decrypted_response.get('message')}")
                return custom_response(code=decrypted_response.get('code'), message=decrypted_response.get('message'))

    except Exception as e:
        await db.rollback()
        logger.error(f"Error deleting user account: {str(e)}", exc_info=True)
        return custom_response(code=500, message=f"Internal server error: {str(e)}")