import datetime
from datetime import timedelta
from flask import request, jsonify
from marshmallow import ValidationError
from app.utils.logger import logger
from app.api.helpers.response_helper import ResponseHelper
from app.api.schemas.generate_token import GenerateTokenRequestSchema, GenerateTokenResponseSchema
from app.config import Config
from flask_jwt_extended import (
    create_access_token,
)


class GenerateTokenService:
    USERNAME = Config.BANK_CALL_BASIC_AUTH_USERNAME
    PASSWORD = Config.BANK_CALL_BASIC_AUTH_PASSWORD
    TYPE = Config.BANK_GRANT_TYPE
    @staticmethod
    def process_request(data):
        """
        Process the GenerateToken request.

        Args:
            data (dict): The request JSON payload.

        Returns:
            tuple: (JSON response, status code)
        """
        try:
            logger.info("Processing GenerateToken request")

            # Step 1: Validate input using schema
            schema = GenerateTokenRequestSchema()
            validated_data = schema.load(data)
            
            logger.info(f"Validated data: {validated_data}")

            username = validated_data.get("username")
            password = validated_data.get("password")
            grant_type = validated_data.get("grant_type")
            
            if password != GenerateTokenService.PASSWORD or username != GenerateTokenService.USERNAME or grant_type != GenerateTokenService.TYPE:
                return {
                    "message": "Invalid credentials",
                    "status": 401
                }
               
            expires_in = 1800
            identity = username
            # Step 2: Generate JWT token
            access_token = create_access_token(identity=identity, expires_delta=timedelta(seconds=expires_in))

            # Step 3: Get client IP address
            ipaddress = request.remote_addr or "127.0.0.1"

            # Step 4: Build response timestamps
            issued_time = datetime.datetime.utcnow()
            expires_time = issued_time + datetime.timedelta(seconds=expires_in)

            # Step 5: Construct response payload
            response_data = {
                "access_token": access_token,
                "token_type": "bearer",
                "expires_in": expires_in,
                "userName": username,
                "ipaddress": ipaddress,
                "errorMessage": "",
                "issued": issued_time,
                "expires": expires_time
            }

            # Serialize with response schema
            response_schema = GenerateTokenResponseSchema()
            response_json = response_schema.dump(response_data)

            return jsonify(response_json), 200

        except ValidationError as err:
            logger.error(f"Validation Error: {err.messages}")
            return jsonify({
                "message": "Validation exception",
                "errors": err.messages
            }), 422

        except Exception as e:
            logger.error(f"An error occurred while generating token: {str(e)}", exc_info=True)
            return jsonify({
                "message": "Internal Server Error"
            }), 500