from flask import session, jsonify

from app.api.schemas.report import ReportSchema
# from app.models.loan import Loan
from app.utils.logger import logger
from app.api.services.base_service import BaseService
# from app.api.schemas.eligibility_check import EligibilityCheckSchema
from marshmallow import ValidationError
# from app.api.enums import TransactionType
# from app.api.integrations import SimbrellaIntegration
from app.extensions import db
from app.models import MembersProducts, Products, Members

# from app.api.services.offer_analysis import OfferAnalysis
from app.api.helpers.response_helper import ResponseHelper
from werkzeug.security import generate_password_hash, check_password_hash
# from app.api.schemas.register import RegisterSchema
from app.api.schemas.products import ProductsSchema
from app.api.schemas.user import UserSchema

import datetime
import jwt
import random
from app.config import Config


class ReportService(BaseService):

    @staticmethod
    def process_report_topic_request(data):
        try:
            with db.session.begin():
                logger.info(f"Incoming ReportService data  ==>>>>  {data}")
                validated_data = ReportService.validate_data(data, UserSchema())
                token = validated_data.get('token')
                uid = validated_data.get('uid')
                member_data = Members.get_member_by_uid(uid)
                member_id = member_data.id

                topics_data = ReportService.configured_report_types()
                response_data = {
                    "last_update": datetime.datetime.utcnow(),
                    "member_id": member_id,
                    "topics": topics_data,
                }

                return ResponseHelper.success(data=response_data)

        except ValidationError as err:

            logger.error(f"Validation Error: {getattr(err, 'messages', str(err))}")
            db.session.rollback()
            return ResponseHelper.unprocessable_entity(result_description="Validation exception")

        except  ValueError as err:
            logger.error(f"{getattr(err, 'messages', str(err))}")
            db.session.rollback()
            return ResponseHelper.error(result_description=str(err))

        except Exception as e:
            logger.error(f"An error occurred: {str(e)}", exc_info=True)
            db.session.rollback()
            return ResponseHelper.internal_server_error()

    @staticmethod
    def configured_report_types():
        data = {
            "topics": [
                {"name": 'Payments', "url": 'payment', "active": True, "list_order": 0},
                {"name": 'Product', "url": 'product', "active": True, "list_order": 1},
                {"name": 'System', "url": 'system', "active": True, "list_order": 2},
            ]

        }
        return data

    @staticmethod
    def process_report_topic_item(report_type, data):
        try:
            with db.session.begin():
                logger.info(f"Incoming ReportService Item Data  ==>>>>  {data}")
                validated_data = ReportService.validate_data(data, ReportSchema())
                token = validated_data.get('token')
                uid = validated_data.get('uid')
                page = validated_data.get('page')


                member_data = Members.get_member_by_uid(uid)
                member_id = member_data.id
                response_data =[]

                if report_type == "Payment":
                    response_data = {
                        "last_update": datetime.datetime.utcnow(),
                        "member_id": member_id,
                        "payment": [],
                    }

                if report_type == "Product":
                    response_data = {
                        "last_update": datetime.datetime.utcnow(),
                        "member_id": member_id,
                        "product": [],
                    }

                if report_type == "System":
                    response_data = {
                        "last_update": datetime.datetime.utcnow(),
                        "member_id": member_id,
                        "system": [],
                    }

                return ResponseHelper.success(data=response_data)

        except ValidationError as err:

            logger.error(f"Validation Error: {getattr(err, 'messages', str(err))}")
            db.session.rollback()
            return ResponseHelper.unprocessable_entity(result_description="Validation exception")

        except  ValueError as err:
            logger.error(f"{getattr(err, 'messages', str(err))}")
            db.session.rollback()
            return ResponseHelper.error(result_description=str(err))

        except Exception as e:
            logger.error(f"An error occurred: {str(e)}", exc_info=True)
            db.session.rollback()
            return ResponseHelper.internal_server_error()