from flask import request
from flask.views import MethodView
from flask_smorest import Blueprint
from src.views.reports.performance import PerformanceReportsManager
from src.views.reports.enrollment import EnrollmentReportsManager
from src.views.reports.utils import ReportsManager
from src.utils import custom_response
from src.views.reports.student_analytics import StudentAnalyticsManager

# Create reports blueprint
reports_router = Blueprint('reports', __name__)


@reports_router.route("/performance/tutors", methods=["GET"])
class TutorPerformanceRouter(MethodView):
    def __init__(self) -> None:
        self.reports_manager = PerformanceReportsManager()

    def get(self):
        """Get comprehensive tutor performance analytics"""
        try:
            # Get query parameters
            period = request.args.get('period', '30d')
            start_date = request.args.get('start_date')
            end_date = request.args.get('end_date')
            department = request.args.get('department')
            supervisor_id = request.args.get('supervisor_id')
            
            return self.reports_manager.get_tutor_performance_analytics(
                period=period,
                start_date=start_date,
                end_date=end_date,
                department=department,
                supervisor_id=supervisor_id
            )
        except Exception as e:
            return custom_response(
                success=False,
                data=f"Failed to fetch tutor performance data: {str(e)}",
                status_code=500
            )

@reports_router.route("/performance/supervisors", methods=["GET"])
class SupervisorPerformanceRouter(MethodView):
    def __init__(self) -> None:
        self.reports_manager = PerformanceReportsManager()

    def get(self):
        """Get comprehensive supervisor performance analytics"""
        try:
            # Get query parameters
            period = request.args.get('period', '30d')
            start_date = request.args.get('start_date')
            end_date = request.args.get('end_date')
            department = request.args.get('department')
            
            return self.reports_manager.get_supervisor_performance_analytics(
                period=period,
                start_date=start_date,
                end_date=end_date,
                department=department
            )
        except Exception as e:
            return custom_response(
                success=False,
                data=f"Failed to fetch supervisor performance data: {str(e)}",
                status_code=500
            )

@reports_router.route("/performance/export", methods=["GET"])
class PerformanceExportRouter(MethodView):
    def __init__(self) -> None:
        self.reports_manager = PerformanceReportsManager()

    def get(self):
        """Export performance data to CSV/Excel"""
        try:
            export_type = request.args.get('type', 'tutors')  # tutors or supervisors
            period = request.args.get('period', '30d')
            format_type = request.args.get('format', 'csv')  # csv or excel
            
            return self.reports_manager.export_performance_data(
                export_type=export_type,
                period=period,
                format_type=format_type
            )
        except Exception as e:
            return custom_response(
                success=False,
                data=f"Failed to export performance data: {str(e)}",
                status_code=500
            )

# Additional routes for existing ReportsManager functionality
@reports_router.route("/academic/<string:user_id>", methods=["GET"])
class AcademicReportRouter(MethodView):
    def __init__(self) -> None:
        self.reports_manager = ReportsManager()

    def get(self, user_id):
        """Generate comprehensive academic performance report"""
        try:
            user_type = request.args.get('user_type', 'student')
            period = request.args.get('period', 'current')
            
            return self.reports_manager.get_academic_report(
                user_id=user_id,
                user_type=user_type,
                period=period
            )
        except Exception as e:
            return custom_response(
                success=False,
                data=f"Failed to generate academic report: {str(e)}",
                status_code=500
            )

@reports_router.route("/attendance", methods=["GET"])
class AttendanceReportRouter(MethodView):
    def __init__(self) -> None:
        self.reports_manager = ReportsManager()

    def get(self):
        """Generate attendance report"""
        try:
            user_id = request.args.get('user_id')
            user_type = request.args.get('user_type', 'student')
            period = request.args.get('period', 'current')
            course_id = request.args.get('course_id')
            
            return self.reports_manager.get_attendance_report(
                user_id=user_id,
                user_type=user_type,
                period=period,
                course_id=course_id
            )
        except Exception as e:
            return custom_response(
                success=False,
                data=f"Failed to generate attendance report: {str(e)}",
                status_code=500
            )

@reports_router.route("/attendance/reports", methods=["GET"])
class AttendanceReportsRouter(MethodView):
    def __init__(self) -> None:
        self.reports_manager = ReportsManager()

    def get(self):
        """Generate comprehensive attendance reports for dashboard"""
        try:
            start_date = request.args.get('start_date')
            end_date = request.args.get('end_date')
            speciality = request.args.get('speciality')
            course_id = request.args.get('course_id')
            include_course = request.args.get('include_course', 'false').lower() == 'true'
            include_tutor = request.args.get('include_tutor', 'false').lower() == 'true'
            
            return self.reports_manager.get_attendance_reports(
                start_date=start_date,
                end_date=end_date,
                speciality=speciality,
                course_id=course_id,
                include_course=include_course,
                include_tutor=include_tutor
            )
        except Exception as e:
            return custom_response(
                success=False,
                data=f"Failed to generate attendance reports: {str(e)}",
                status_code=500
            )

@reports_router.route("/progress/<string:user_id>", methods=["GET"])
class ProgressReportRouter(MethodView):
    def __init__(self) -> None:
        self.reports_manager = ReportsManager()

    def get(self, user_id):
        """Generate progress report for a user"""
        try:
            user_type = request.args.get('user_type', 'student')
            period = request.args.get('period', 'current')
            
            return self.reports_manager.get_progress_report(
                user_id=user_id,
                user_type=user_type,
                period=period
            )
        except Exception as e:
            return custom_response(
                success=False,
                data=f"Failed to generate progress report: {str(e)}",
                status_code=500
            )

@reports_router.route("/analytics", methods=["GET"])
class AnalyticsReportRouter(MethodView):
    def __init__(self) -> None:
        self.reports_manager = ReportsManager()

    def get(self):
        """Generate system analytics report"""
        try:
            period = request.args.get('period', 'current')
            report_type = request.args.get('type', 'overview')
            
            return self.reports_manager.get_analytics_report(
                period=period,
                report_type=report_type
            )
        except Exception as e:
            return custom_response(
                success=False,
                data=f"Failed to generate analytics report: {str(e)}",
                status_code=500
            )

@reports_router.route("/performance/top-performers", methods=["GET"])
class TopPerformersRouter(MethodView):
    def __init__(self) -> None:
        self.reports_manager = PerformanceReportsManager()

    def get(self):
        """Get top 10 performing tutors and supervisors"""
        try:
            period = request.args.get('period', '30d')
            limit = int(request.args.get('limit', 10))
            
            # Calculate date range
            date_range = self.reports_manager._calculate_date_range(period)
            
            result = self.reports_manager.get_top_performers_analytics(date_range, limit)
            return result
            
        except Exception as e:
            return custom_response(
                success=False,
                data={'error': f"Error retrieving top performers: {str(e)}"},
                status_code=500
            )

@reports_router.route("/enrollment/analytics", methods=["GET"])
class EnrollmentAnalyticsRouter(MethodView):
    def __init__(self) -> None:
        self.enrollment_manager = EnrollmentReportsManager()

    def get(self):
        """Get comprehensive enrollment analytics"""
        try:
            period = request.args.get('period', '30d')
            start_date = request.args.get('start_date')
            end_date = request.args.get('end_date')
            department = request.args.get('department')
            course_id = request.args.get('course_id')
            
            result = self.enrollment_manager.get_enrollment_analytics(
                period=period,
                start_date=start_date,
                end_date=end_date,
                department=department,
                course_id=course_id
            )
            return result
            
        except Exception as e:
                    return custom_response(
                        success=False,
                        data=f"Error retrieving enrollment analytics: {str(e)}",
                        status_code=500
                    )

@reports_router.route("/enrollment/export", methods=["GET"])
class EnrollmentExportRouter(MethodView):
    def __init__(self) -> None:
        self.enrollment_manager = EnrollmentReportsManager()

    def get(self):
        """Export enrollment data to CSV or Excel"""
        try:
            period = request.args.get('period', '30d')
            format_type = request.args.get('format', 'csv')
            
            result = self.enrollment_manager.export_enrollment_data(period, format_type)
            
            if result.data.get('success'):
                from flask import make_response
                return make_response(
                    result.data.get('content', ''),
                    200,
                    {
                        'Content-Type': result.data.get('content_type', 'text/csv'),
                        'Content-Disposition': f'attachment; filename="{result.data.get("filename", "export.csv")}"'
                    }
                )
            else:
                return result
            
        except Exception as e:
            return custom_response(
                success=False,
                data={'error': f"Error exporting enrollment data: {str(e)}"},
                status_code=500
            )

# Student Analytics Routes - Real Database Version
@reports_router.route("/analytics/students/enrollments/departments", methods=["GET"])
class StudentEnrollmentDepartmentsRouter(MethodView):
    def __init__(self) -> None:
        self.analytics_manager = StudentAnalyticsManager()

    def get(self):
        """Get unique departments from supervisor departments for enrollment"""
        return self.analytics_manager.get_enrollment_departments()

@reports_router.route("/analytics/students/enrollments", methods=["GET"])
class StudentEnrollmentAnalyticsRouter(MethodView):
    def __init__(self) -> None:
        self.analytics_manager = StudentAnalyticsManager()

    def get(self):
        """Get comprehensive student enrollment analytics"""
        try:
            period = request.args.get('period', '30d')
            department = request.args.get('department')
            status = request.args.get('status')
            
            filters = {}
            if department:
                filters['department'] = department
            if status:
                filters['status'] = status
            
            return self.analytics_manager.get_student_enrollment_analytics(period, **filters)
            
        except Exception as e:
                    return custom_response(
                        success=False,
                        data=f"Error retrieving enrollment analytics: {str(e)}",
                        status_code=500
                    )

@reports_router.route("/analytics/students/enrollments/records", methods=["GET"])
class StudentEnrollmentRecordsRouter(MethodView):
    def __init__(self) -> None:
        self.analytics_manager = StudentAnalyticsManager()

    def get(self):
        """Get paginated enrollment records with filtering"""
        try:
            page = int(request.args.get('page', 1))
            limit = int(request.args.get('limit', 10))
            
            filters = {}
            
            # Add filters from query parameters
            search_params = ['search', 'department', 'speciality', 'status', 
                           'payment_status', 'academic_year', 'semester']
            
            for param in search_params:
                if request.args.get(param):
                    filters[param] = request.args.get(param)
            
            return self.analytics_manager.get_student_enrollment_records(page, limit, **filters)
            
        except Exception as e:
            return custom_response(
                success=False,
                data=f"Error retrieving enrollment records: {str(e)}",
                status_code=500
            )

@reports_router.route("/analytics/students/enrollments/specialities", methods=["GET"])
class StudentEnrollmentSpecialitiesRouter(MethodView):
    def __init__(self) -> None:
        self.analytics_manager = StudentAnalyticsManager()

    def get(self):
        """Get specialities for enrollment by department"""
        try:
            department = request.args.get('department')
            return self.analytics_manager.get_department_specialities(department)
            
        except Exception as e:
            return custom_response(
                success=False,
                data=f"Error retrieving specialities: {str(e)}",
                status_code=500
            )

@reports_router.route("/analytics/students/enrollments/courses", methods=["GET"])
class StudentEnrollmentCoursesRouter(MethodView):
    def __init__(self) -> None:
        self.analytics_manager = StudentAnalyticsManager()

    def get(self):
        """Get courses for enrollment by speciality"""
        try:
            speciality = request.args.get('speciality')
            if not speciality:
                return custom_response(
                    success=False,
                    data="Speciality parameter is required",
                    status_code=400
                )
            return self.analytics_manager.get_speciality_courses(speciality)
            
        except Exception as e:
            return custom_response(
                success=False,
                data=f"Error retrieving courses: {str(e)}",
                status_code=500
            )

@reports_router.route("/analytics/students/enrollments/eligible-students", methods=["GET"])
class StudentEnrollmentEligibleStudentsRouter(MethodView):
    def __init__(self) -> None:
        self.analytics_manager = StudentAnalyticsManager()

    def get(self):
        """Get students without enrollments (eligible for new enrollment)"""
        try:
            search = request.args.get('search')
            return self.analytics_manager.get_students_without_enrollments(search)
        except Exception as e:
            return custom_response(
                success=False,
                data=f"Error retrieving eligible students: {str(e)}",
                status_code=500
            )

@reports_router.route("/analytics/students", methods=["GET"])
class StudentAnalyticsRouter(MethodView):
    def __init__(self) -> None:
        self.analytics_manager = StudentAnalyticsManager()

    def get(self):
        """Get comprehensive student analytics data from database"""
        try:
            period = request.args.get('period', '30d')
            start_date = request.args.get('start_date')
            end_date = request.args.get('end_date')
            department = request.args.get('department')
            status = request.args.get('status')
            
            # Create filters dictionary
            filters = {}
            if start_date:
                filters['start_date'] = start_date


            if end_date:
                filters['end_date'] = end_date
            if department:
                filters['department'] = department
            if status:
                filters['status'] = status
            
            # Get real analytics data from database
            overview_result = self.analytics_manager.get_student_overview_analytics(period, **filters)
            attendance_result = self.analytics_manager.get_attendance_analytics(period, **filters)
            performance_result = self.analytics_manager.get_performance_analytics(period, **filters)
            assignment_result = self.analytics_manager.get_assignment_analytics(period, **filters)
            
            # Extract data from response objects
            overview_data = overview_result.get_json()['data'] if overview_result.status_code == 200 else {}
            attendance_data = attendance_result.get_json()['data'] if attendance_result.status_code == 200 else {}
            performance_data = performance_result.get_json()['data'] if performance_result.status_code == 200 else {}
            assignment_data = assignment_result.get_json()['data'] if assignment_result.status_code == 200 else {}
            
            # Compile the response data
            analytics_data = {
                'overview': overview_data,
                'attendance_stats': attendance_data,
                'performance_stats': performance_data,
                'assignment_stats': assignment_data,
                'date_range': {
                    'start': filters.get('start_date'),
                    'end': filters.get('end_date'),
                    'period': period
                },
                'filters': {
                    'department': filters.get('department'),
                    'status': filters.get('status')
                }
            }
            
            return custom_response(
                success=True,
                data=analytics_data,
                status_code=200
            )
        except Exception as e:
            return custom_response(
                success=False,
                data={'error': f"Error retrieving student analytics: {str(e)}"},
                status_code=500
            )

# Student Attendance Analytics Routes
@reports_router.route("/analytics/students/attendance", methods=["GET"])
class StudentAttendanceAnalyticsRouter(MethodView):
    def __init__(self) -> None:
        self.analytics_manager = StudentAnalyticsManager()

    def get(self):
        """Get comprehensive student attendance analytics data"""
        try:
            # Get query parameters
            period = request.args.get('period', '30d')
            start_date = request.args.get('start_date')
            end_date = request.args.get('end_date')
            department = request.args.get('department')
            speciality = request.args.get('speciality')
            course = request.args.get('course')
            status = request.args.get('status')
            student_search = request.args.get('student_search', '')
            
            # Get analytics data from database
            attendance_analytics_result = self.analytics_manager.get_detailed_attendance_analytics(
                period=period,
                start_date=start_date,
                end_date=end_date,
                department=department,
                speciality=speciality,
                course=course,
                status=status,
                student_search=student_search
            )
            
            # Extract data from response object
            if attendance_analytics_result.status_code == 200:
                analytics_data = attendance_analytics_result.get_json()['data']
            else:
                analytics_data = {}
            
            return custom_response(
                success=True,
                data=analytics_data,
                status_code=200
            )
        except Exception as e:
            return custom_response(
                success=False,
                data={'error': f"Error retrieving student attendance analytics: {str(e)}"},
                status_code=500
            )