import logging
import sys
from flask import jsonify, request
from pydantic import ValidationError
from schemas.basic_response_schema import ResponseSchema
from schemas.google_login_schema import GoogleLoginSchema
from schemas import LoginSchema
from services import UserService, AuthService

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)


class AuthController:
    def __init__(self, userService: UserService, authService: AuthService):
        self.user_service = userService
        self.auth_service = authService

    def login(self):
        data = request.get_json()
        dataSchema = LoginSchema(**data)
        response = self.auth_service.login(dataSchema)

        if response.success:
            return jsonify(response.to_dict()), 200
        return jsonify(response.to_dict()), 400

    def google_login(self):
        """Handles Google Login via ID Token verification"""
        try:
            data = request.get_json()

            # Validasi data dengan Pydantic
            validated_data = GoogleLoginSchema(**data)
            id_token = validated_data.token_id

            # Verifikasi ID Token ke layanan AuthService
            user_info = self.auth_service.verify_google_id_token(id_token)
            if not user_info:
                logger.error("Invalid Google ID Token")
                response = ResponseSchema(
                    message="Invalid Google ID Token", data=None, meta=None
                )
                return jsonify(response.model_dump()), 401

            # Jika berhasil, kembalikan data user tanpa meta
            response = ResponseSchema(
                message="Login successful",
                data=user_info,
                meta=None,  # Karena ini single data, tidak ada meta
            )
            return jsonify(response.model_dump()), 200

        except ValidationError as e:
            logger.error(f"Validation error: {e}")
            response = ResponseSchema(message="Invalid input", data=None, meta=None)
            return jsonify(response.model_dump()), 400

        except Exception as e:
            logger.error(f"Error during Google login: {str(e)}", exc_info=True)
            response = ResponseSchema(
                message="Internal server error", data=None, meta=None
            )
            return jsonify(response.model_dump()), 500

    def register(self):
        return jsonify({"message": "register"}), 200

    def logout(self):
        return jsonify({"message": "logout"}), 200

    def test(self):
        return "test"