import 'dart:convert';

import 'package:http/http.dart' as http;

import '../networks/api_client.dart';

class HodAssignment {
  final int id;
  final int departmentId;
  final String departmentName;
  final String campus;
  final String school;
  final int staffUserId;
  final String staffName;
  final String staffEmail;
  final int assignedBy;
  final String assignedByName;
  final bool isActive;
  final DateTime? assignedAt;
  final DateTime? endedAt;

  const HodAssignment({
    required this.id,
    required this.departmentId,
    required this.departmentName,
    required this.campus,
    required this.school,
    required this.staffUserId,
    required this.staffName,
    required this.staffEmail,
    required this.assignedBy,
    required this.assignedByName,
    required this.isActive,
    required this.assignedAt,
    required this.endedAt,
  });

  factory HodAssignment.fromJson(Map<String, dynamic> json) {
    return HodAssignment(
      id: _int(json['id']),
      departmentId: _int(json['department_id']),
      departmentName: _text(json['department_name']),
      campus: _text(json['campus']),
      school: _text(json['school']),
      staffUserId: _int(json['staff_user_id']),
      staffName: _text(json['staff_name']),
      staffEmail: _text(json['staff_email']),
      assignedBy: _int(json['assigned_by']),
      assignedByName: _text(json['assigned_by_name']),
      isActive: _bool(json['is_active']),
      assignedAt: _date(json['assigned_at']),
      endedAt: _date(json['ended_at']),
    );
  }
}

class PromotionPerformanceRecord {
  final int id;
  final int departmentId;
  final String departmentName;
  final String campus;
  final String school;
  final String academicYear;
  final String examSession;
  final String levelName;
  final int satCount;
  final int passedCount;
  final int failedCount;
  final double passRate;
  final String notes;
  final int hodAssignmentId;
  final int submittedBy;
  final String submittedByName;
  final DateTime? createdAt;
  final DateTime? updatedAt;

  const PromotionPerformanceRecord({
    required this.id,
    required this.departmentId,
    required this.departmentName,
    required this.campus,
    required this.school,
    required this.academicYear,
    required this.examSession,
    required this.levelName,
    required this.satCount,
    required this.passedCount,
    required this.failedCount,
    required this.passRate,
    required this.notes,
    required this.hodAssignmentId,
    required this.submittedBy,
    required this.submittedByName,
    required this.createdAt,
    required this.updatedAt,
  });

  factory PromotionPerformanceRecord.fromJson(Map<String, dynamic> json) {
    return PromotionPerformanceRecord(
      id: _int(json['id']),
      departmentId: _int(json['department_id']),
      departmentName: _text(json['department_name']),
      campus: _text(json['campus']),
      school: _text(json['school']),
      academicYear: _text(json['academic_year']),
      examSession: _text(json['exam_session']),
      levelName: _text(json['level_name']),
      satCount: _int(json['sat_count']),
      passedCount: _int(json['passed_count']),
      failedCount: _int(json['failed_count']),
      passRate: _double(json['pass_rate']),
      notes: _text(json['notes']),
      hodAssignmentId: _int(json['hod_assignment_id']),
      submittedBy: _int(json['submitted_by']),
      submittedByName: _text(json['submitted_by_name']),
      createdAt: _date(json['created_at']),
      updatedAt: _date(json['updated_at']),
    );
  }
}

class PerformanceSummary {
  final int records;
  final int sat;
  final int passed;
  final int failed;
  final double passRate;

  const PerformanceSummary({
    required this.records,
    required this.sat,
    required this.passed,
    required this.failed,
    required this.passRate,
  });

  factory PerformanceSummary.fromJson(Map<String, dynamic> json) {
    return PerformanceSummary(
      records: _int(json['records']),
      sat: _int(json['sat']),
      passed: _int(json['passed']),
      failed: _int(json['failed']),
      passRate: _double(json['pass_rate']),
    );
  }

  static const empty = PerformanceSummary(
    records: 0,
    sat: 0,
    passed: 0,
    failed: 0,
    passRate: 0,
  );
}

class PerformancePage {
  final List<PromotionPerformanceRecord> records;
  final PerformanceSummary summary;
  final bool isAdmin;

  const PerformancePage({
    required this.records,
    required this.summary,
    required this.isAdmin,
  });
}

class StudentPerformanceService {
  static bool roleIsAdmin(String role) {
    final value = role.toLowerCase().trim();
    return <String>{'admin', 'administrator', 'superadmin', 'super_admin', 'super admin'}
        .contains(value);
  }

  static Future<Map<String, dynamic>> getCurrentUser() {
    return ApiClient.getCurrentLoggedInUser();
  }

  static Future<List<Map<String, dynamic>>> getDepartments() async {
    final raw = await ApiClient.getDepartments();
    return raw.whereType<Map>().map((item) {
      return item.map((key, value) => MapEntry(key.toString(), value));
    }).toList();
  }

  static Future<List<Map<String, dynamic>>> getCampuses() async {
    final raw = await ApiClient.getCampuses();
    return raw.whereType<Map>().map((item) {
      return item.map((key, value) => MapEntry(key.toString(), value));
    }).toList();
  }

  static Future<List<Map<String, dynamic>>> getStaff() async {
    return ApiClient.getStaff();
  }

  static Future<List<HodAssignment>> getHodAssignments({bool history = false}) async {
    final uri = Uri.parse('${ApiClient.baseUrl}/api/hod_assignments.php').replace(
      queryParameters: history ? const {'history': '1'} : null,
    );
    final response = await ApiClient.offlineFirstGet(uri, headers: await ApiClient.getHeaders())
        .timeout(const Duration(seconds: 20));
    await ApiClient.handleUnauthorized(response);
    _ensureSuccess(response, const {200});
    final decoded = _decode(response);
    final raw = decoded is Map ? decoded['data'] : null;
    if (raw is! List) return const <HodAssignment>[];
    return raw.whereType<Map>().map((item) {
      return HodAssignment.fromJson(
        item.map((key, value) => MapEntry(key.toString(), value)),
      );
    }).toList();
  }

  static Future<void> assignHod({
    required int departmentId,
    required String campus,
    required int staffUserId,
  }) async {
    final response = await http.post(
      Uri.parse('${ApiClient.baseUrl}/api/hod_assignments.php'),
      headers: await ApiClient.getHeaders(),
      body: jsonEncode({
        'department_id': departmentId,
        'campus': campus,
        'staff_user_id': staffUserId,
      }),
    ).timeout(const Duration(seconds: 20));
    await ApiClient.handleUnauthorized(response);
    _ensureSuccess(response, const {200, 201});
  }

  static Future<void> endHodAssignment(int id) async {
    final uri = Uri.parse('${ApiClient.baseUrl}/api/hod_assignments.php')
        .replace(queryParameters: {'id': '$id'});
    final response = await http.delete(uri, headers: await ApiClient.getHeaders())
        .timeout(const Duration(seconds: 20));
    await ApiClient.handleUnauthorized(response);
    _ensureSuccess(response, const {200, 204});
  }

  static Future<PerformancePage> getPerformance({
    int? departmentId,
    String? campus,
    String? academicYear,
    String? examSession,
  }) async {
    final query = <String, String>{};
    if (departmentId != null && departmentId > 0) query['department_id'] = '$departmentId';
    if ((campus ?? '').trim().isNotEmpty) query['campus'] = campus!.trim();
    if ((academicYear ?? '').trim().isNotEmpty) query['academic_year'] = academicYear!.trim();
    if ((examSession ?? '').trim().isNotEmpty) query['exam_session'] = examSession!.trim();

    final uri = Uri.parse('${ApiClient.baseUrl}/api/promotion_performance.php')
        .replace(queryParameters: query.isEmpty ? null : query);
    final response = await ApiClient.offlineFirstGet(uri, headers: await ApiClient.getHeaders())
        .timeout(const Duration(seconds: 20));
    await ApiClient.handleUnauthorized(response);
    _ensureSuccess(response, const {200});

    final decoded = _decode(response);
    if (decoded is! Map) {
      throw const FormatException('Performance API returned an invalid response.');
    }
    final raw = decoded['data'];
    final records = <PromotionPerformanceRecord>[];
    if (raw is List) {
      for (final item in raw.whereType<Map>()) {
        records.add(PromotionPerformanceRecord.fromJson(
          item.map((key, value) => MapEntry(key.toString(), value)),
        ));
      }
    }
    final summaryRaw = decoded['summary'];
    final summary = summaryRaw is Map
        ? PerformanceSummary.fromJson(
            summaryRaw.map((key, value) => MapEntry(key.toString(), value)),
          )
        : PerformanceSummary.empty;
    return PerformancePage(
      records: records,
      summary: summary,
      isAdmin: _bool(decoded['is_admin']),
    );
  }

  static Future<void> createPerformance({
    required int departmentId,
    required String academicYear,
    required String examSession,
    required String levelName,
    required int satCount,
    required int passedCount,
    String notes = '',
  }) async {
    final response = await http.post(
      Uri.parse('${ApiClient.baseUrl}/api/promotion_performance.php'),
      headers: await ApiClient.getHeaders(),
      body: jsonEncode({
        'department_id': departmentId,
        'academic_year': academicYear,
        'exam_session': examSession,
        'level_name': levelName,
        'sat_count': satCount,
        'passed_count': passedCount,
        'notes': notes,
      }),
    ).timeout(const Duration(seconds: 20));
    await ApiClient.handleUnauthorized(response);
    _ensureSuccess(response, const {200, 201});
  }

  static Future<void> updatePerformance(
    int id, {
    required String academicYear,
    required String examSession,
    required String levelName,
    required int satCount,
    required int passedCount,
    String notes = '',
  }) async {
    final uri = Uri.parse('${ApiClient.baseUrl}/api/promotion_performance.php')
        .replace(queryParameters: {'id': '$id'});
    final response = await http.put(
      uri,
      headers: await ApiClient.getHeaders(),
      body: jsonEncode({
        'academic_year': academicYear,
        'exam_session': examSession,
        'level_name': levelName,
        'sat_count': satCount,
        'passed_count': passedCount,
        'notes': notes,
      }),
    ).timeout(const Duration(seconds: 20));
    await ApiClient.handleUnauthorized(response);
    _ensureSuccess(response, const {200, 204});
  }

  static Future<void> deletePerformance(int id) async {
    final uri = Uri.parse('${ApiClient.baseUrl}/api/promotion_performance.php')
        .replace(queryParameters: {'id': '$id'});
    final response = await http.delete(uri, headers: await ApiClient.getHeaders())
        .timeout(const Duration(seconds: 20));
    await ApiClient.handleUnauthorized(response);
    _ensureSuccess(response, const {200, 204});
  }

  static dynamic _decode(http.Response response) {
    try {
      return jsonDecode(response.body);
    } on FormatException {
      throw Exception(
        'The server returned invalid JSON (HTTP ${response.statusCode}). '
        'Check the PHP error log for ${response.request?.url}.',
      );
    }
  }

  static void _ensureSuccess(http.Response response, Set<int> accepted) {
    if (accepted.contains(response.statusCode)) return;
    String detail = '';
    try {
      final decoded = jsonDecode(response.body);
      if (decoded is Map) {
        detail = _text(decoded['detail'] ?? decoded['message'] ?? decoded['error']);
      }
    } catch (_) {}
    if (detail.isEmpty) detail = 'Request failed with HTTP ${response.statusCode}.';
    throw Exception(detail);
  }
}

int _int(dynamic value) => int.tryParse('${value ?? 0}') ?? 0;
double _double(dynamic value) => double.tryParse('${value ?? 0}') ?? 0;
String _text(dynamic value) {
  final text = value?.toString().trim() ?? '';
  return text.toLowerCase() == 'null' ? '' : text;
}
bool _bool(dynamic value) {
  if (value is bool) return value;
  final text = '${value ?? ''}'.toLowerCase();
  return text == 'true' || text == '1' || text == 'yes';
}
DateTime? _date(dynamic value) {
  final text = _text(value);
  return text.isEmpty ? null : DateTime.tryParse(text);
}
