from flask import jsonify, request, current_app
from pydantic import ValidationError
from app.schemas.basic_response_schema import ResponseSchema
from app.schemas.google_login_schema import GoogleLoginSchema
from app.schemas import LoginSchema
from app.services import UserService, AuthService
from app.exception import AuthException
from app.mapper import UserMapper
from app.helpers import make_response, make_error_response
import logging

logging = logging.getLogger(__name__)


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

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

            if response is None:
                return make_response(message="User is not registered", status_code=401)
            return make_response(message="Login success", data=response)
        except ValidationError as e:
            current_app.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:
            current_app.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 google_login(self):
        """Handles Google Login via ID Token verification"""
        try:
            data = request.get_json()

            validated_data = GoogleLoginSchema(**data)
            id_token = validated_data.token_id

            user_info = self.auth_service.verify_google_id_token(id_token)
            if not user_info:
                return make_response(message="Invalid Google ID Token", data=user_info)

            return make_response(message="Login Success", data=user_info)

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

        except AuthException as e:
            current_app.logger.error(f"Auth error: {e}")
            response = ResponseSchema(message=e, data=None, meta=None)
            return jsonify(response.model_dump()), 400

        except Exception as e:
            current_app.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 logout(self):
        return jsonify({"message": "logout"}), 200