import 'dart:convert';
import 'dart:io';

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

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

class ClubCurrentUser {
  final int id;
  final String fullName;
  final String email;
  final String phone;
  final String role;
  final String campus;
  final String school;
  final String program;
  final String profilePicture;

  const ClubCurrentUser({
    required this.id,
    required this.fullName,
    required this.email,
    required this.phone,
    required this.role,
    required this.campus,
    required this.school,
    required this.program,
    required this.profilePicture,
  });

  bool get isAdmin {
    final value = role.toLowerCase().trim().replaceAll(' ', '_');
    return const {
      'admin',
      'administrator',
      'superadmin',
      'super_admin',
    }.contains(value);
  }

  factory ClubCurrentUser.fromJson(Map<String, dynamic> json) {
    return ClubCurrentUser(
      id: int.tryParse('${json['id'] ?? 0}') ?? 0,
      fullName: '${json['full_name'] ?? json['fullName'] ?? 'Rockview User'}'.trim(),
      email: '${json['email'] ?? ''}'.trim(),
      phone: '${json['phone'] ?? ''}'.trim(),
      role: '${json['role'] ?? ''}'.trim(),
      campus: '${json['campus'] ?? ''}'.trim(),
      school: '${json['school'] ?? ''}'.trim(),
      program: '${json['program'] ?? json['department'] ?? ''}'.trim(),
      profilePicture: '${json['profile_picture'] ?? ''}'.trim(),
    );
  }
}

class CampusClub {
  final int id;
  final int createdBy;
  final String name;
  final String acronym;
  final String category;
  final String purpose;
  final String description;
  final String campus;
  final String patronName;
  final String contactEmail;
  final String contactPhone;
  final String meetingSchedule;
  final String meetingVenue;
  final String status;
  final String rejectionReason;
  final String creatorName;
  final String creatorRole;
  final String creatorProfilePicture;
  final int memberCount;
  final int documentCount;
  final DateTime createdAt;
  final DateTime updatedAt;
  final DateTime? approvedAt;

  const CampusClub({
    required this.id,
    required this.createdBy,
    required this.name,
    required this.acronym,
    required this.category,
    required this.purpose,
    required this.description,
    required this.campus,
    required this.patronName,
    required this.contactEmail,
    required this.contactPhone,
    required this.meetingSchedule,
    required this.meetingVenue,
    required this.status,
    required this.rejectionReason,
    required this.creatorName,
    required this.creatorRole,
    required this.creatorProfilePicture,
    required this.memberCount,
    required this.documentCount,
    required this.createdAt,
    required this.updatedAt,
    required this.approvedAt,
  });

  bool get isActive => status.toLowerCase() == 'active';
  bool get isPending => status.toLowerCase() == 'pending';
  bool get isRejected => status.toLowerCase() == 'rejected';

  factory CampusClub.fromJson(Map<String, dynamic> json) {
    return CampusClub(
      id: int.tryParse('${json['id'] ?? 0}') ?? 0,
      createdBy: int.tryParse('${json['created_by'] ?? 0}') ?? 0,
      name: '${json['name'] ?? ''}',
      acronym: '${json['acronym'] ?? ''}',
      category: '${json['category'] ?? 'General'}',
      purpose: '${json['purpose'] ?? ''}',
      description: '${json['description'] ?? ''}',
      campus: '${json['campus'] ?? ''}',
      patronName: '${json['patron_name'] ?? ''}',
      contactEmail: '${json['contact_email'] ?? ''}',
      contactPhone: '${json['contact_phone'] ?? ''}',
      meetingSchedule: '${json['meeting_schedule'] ?? ''}',
      meetingVenue: '${json['meeting_venue'] ?? ''}',
      status: '${json['status'] ?? 'pending'}',
      rejectionReason: '${json['rejection_reason'] ?? ''}',
      creatorName: '${json['creator_name'] ?? 'Rockview Staff'}',
      creatorRole: '${json['creator_role'] ?? 'staff'}',
      creatorProfilePicture: '${json['creator_profile_picture'] ?? ''}',
      memberCount: int.tryParse('${json['member_count'] ?? 0}') ?? 0,
      documentCount: int.tryParse('${json['document_count'] ?? 0}') ?? 0,
      createdAt: DateTime.tryParse('${json['created_at'] ?? ''}') ?? DateTime.now(),
      updatedAt: DateTime.tryParse('${json['updated_at'] ?? ''}') ?? DateTime.now(),
      approvedAt: DateTime.tryParse('${json['approved_at'] ?? ''}'),
    );
  }
}

class ClubMember {
  final int id;
  final int clubId;
  final String fullName;
  final String memberNumber;
  final String memberType;
  final String clubRole;
  final String email;
  final String phone;
  final String status;
  final DateTime joinedAt;
  final DateTime createdAt;

  const ClubMember({
    required this.id,
    required this.clubId,
    required this.fullName,
    required this.memberNumber,
    required this.memberType,
    required this.clubRole,
    required this.email,
    required this.phone,
    required this.status,
    required this.joinedAt,
    required this.createdAt,
  });

  factory ClubMember.fromJson(Map<String, dynamic> json) {
    return ClubMember(
      id: int.tryParse('${json['id'] ?? 0}') ?? 0,
      clubId: int.tryParse('${json['club_id'] ?? 0}') ?? 0,
      fullName: '${json['full_name'] ?? ''}',
      memberNumber: '${json['member_number'] ?? ''}',
      memberType: '${json['member_type'] ?? 'Student'}',
      clubRole: '${json['club_role'] ?? 'Member'}',
      email: '${json['email'] ?? ''}',
      phone: '${json['phone'] ?? ''}',
      status: '${json['status'] ?? 'active'}',
      joinedAt: DateTime.tryParse('${json['joined_at'] ?? ''}') ?? DateTime.now(),
      createdAt: DateTime.tryParse('${json['created_at'] ?? ''}') ?? DateTime.now(),
    );
  }
}

class ClubDocument {
  final int id;
  final int clubId;
  final String documentType;
  final String originalName;
  final String mimeType;
  final int fileSize;
  final String uploadedByName;
  final DateTime createdAt;

  const ClubDocument({
    required this.id,
    required this.clubId,
    required this.documentType,
    required this.originalName,
    required this.mimeType,
    required this.fileSize,
    required this.uploadedByName,
    required this.createdAt,
  });

  factory ClubDocument.fromJson(Map<String, dynamic> json) {
    return ClubDocument(
      id: int.tryParse('${json['id'] ?? 0}') ?? 0,
      clubId: int.tryParse('${json['club_id'] ?? 0}') ?? 0,
      documentType: '${json['document_type'] ?? 'Club Document'}',
      originalName: '${json['original_name'] ?? json['file_name'] ?? 'document'}',
      mimeType: '${json['mime_type'] ?? 'application/octet-stream'}',
      fileSize: int.tryParse('${json['file_size'] ?? 0}') ?? 0,
      uploadedByName: '${json['uploaded_by_name'] ?? 'Rockview Staff'}',
      createdAt: DateTime.tryParse('${json['created_at'] ?? ''}') ?? DateTime.now(),
    );
  }
}

class ClubLocalDocument {
  final String name;
  final String path;

  const ClubLocalDocument({required this.name, required this.path});
}

class ClubPage {
  final List<CampusClub> clubs;
  final int total;

  const ClubPage({required this.clubs, required this.total});
}

class CampusClubsService {
  static const List<String> categories = <String>[
    'Academic & Professional',
    'Arts & Culture',
    'Community Service',
    'Entrepreneurship & Innovation',
    'Faith & Fellowship',
    'Health & Wellness',
    'Leadership & Governance',
    'Media & Communication',
    'Sports & Recreation',
    'Technology & Science',
    'Other',
  ];

  static const List<String> memberTypes = <String>[
    'Student',
    'Staff',
    'Alumni',
    'Patron / Adviser',
    'Other',
  ];

  static const List<String> memberRoles = <String>[
    'Member',
    'President',
    'Vice President',
    'Secretary',
    'Treasurer',
    'Committee Member',
    'Patron',
    'Adviser',
  ];

  static const List<String> documentTypes = <String>[
    'Club Constitution',
    'Rules & Regulations',
    'Registration Document',
    'Meeting Minutes',
    'Activity Plan',
    'Financial / Budget Document',
    'Other',
  ];

  static dynamic _decode(http.Response response) {
    try {
      return jsonDecode(utf8.decode(response.bodyBytes, allowMalformed: true));
    } catch (_) {
      return null;
    }
  }

  static String _errorMessage(http.Response response, String fallback) {
    final data = _decode(response);
    if (data is Map) {
      final message = data['detail'] ?? data['message'] ?? data['error'];
      if (message != null && message.toString().trim().isNotEmpty) {
        return message.toString().trim();
      }
    }
    return '$fallback (HTTP ${response.statusCode})';
  }

  static Future<http.Response> _get(Uri uri) async {
    final response = await http
        .get(uri, headers: await ApiClient.getHeaders())
        .timeout(const Duration(seconds: 20));
    await ApiClient.handleUnauthorized(response);
    return response;
  }

  static Future<ClubCurrentUser> getCurrentUser() async {
    final response = await _get(Uri.parse('${ApiClient.baseUrl}/api/users.php/me'));
    if (response.statusCode != 200) {
      throw Exception(_errorMessage(response, 'Unable to load the signed-in user.'));
    }
    dynamic data = _decode(response);
    if (data is Map && data['user'] is Map) data = data['user'];
    if (data is Map && data['data'] is Map) data = data['data'];
    if (data is! Map) throw const FormatException('The user endpoint returned invalid data.');
    return ClubCurrentUser.fromJson(
      data.map((key, value) => MapEntry(key.toString(), value)),
    );
  }

  static Future<List<String>> getCampuses() async {
    final response = await _get(Uri.parse('${ApiClient.baseUrl}/api/campuses.php'));
    if (response.statusCode != 200) return const <String>[];
    dynamic data = _decode(response);
    if (data is Map) data = data['campuses'] ?? data['data'];
    if (data is! List) return const <String>[];
    final campuses = <String>{};
    for (final item in data) {
      if (item is Map) {
        final name = '${item['name'] ?? item['campus'] ?? ''}'.trim();
        if (name.isNotEmpty) campuses.add(name);
      } else {
        final name = '$item'.trim();
        if (name.isNotEmpty) campuses.add(name);
      }
    }
    final result = campuses.toList()..sort((a, b) => a.toLowerCase().compareTo(b.toLowerCase()));
    return result;
  }

  static Future<ClubPage> getClubs({
    String status = 'active',
    String campus = '',
    String search = '',
    String category = '',
    String scope = 'directory',
    int limit = 200,
  }) async {
    final uri = Uri.parse('${ApiClient.baseUrl}/api/club_registry.php').replace(
      queryParameters: <String, String>{
        'status': status,
        'scope': scope,
        'limit': '$limit',
        if (campus.trim().isNotEmpty) 'campus': campus.trim(),
        if (search.trim().isNotEmpty) 'q': search.trim(),
        if (category.trim().isNotEmpty) 'category': category.trim(),
      },
    );
    final response = await _get(uri);
    if (response.statusCode != 200) {
      throw Exception(_errorMessage(response, 'Unable to load clubs.'));
    }
    final data = _decode(response);
    if (data is! Map) throw const FormatException('Club directory returned invalid data.');
    final raw = data['data'];
    final clubs = <CampusClub>[];
    if (raw is List) {
      for (final item in raw) {
        if (item is Map) {
          clubs.add(CampusClub.fromJson(
            item.map((key, value) => MapEntry(key.toString(), value)),
          ));
        }
      }
    }
    return ClubPage(
      clubs: clubs,
      total: int.tryParse('${data['total'] ?? clubs.length}') ?? clubs.length,
    );
  }

  static Future<CampusClub> getClub(int clubId) async {
    final response = await _get(
      Uri.parse('${ApiClient.baseUrl}/api/club_registry.php/$clubId'),
    );
    if (response.statusCode != 200) {
      throw Exception(_errorMessage(response, 'Unable to load the club.'));
    }
    final data = _decode(response);
    if (data is! Map) throw const FormatException('Club details returned invalid data.');
    return CampusClub.fromJson(
      data.map((key, value) => MapEntry(key.toString(), value)),
    );
  }

  static Future<CampusClub> createClub(Map<String, dynamic> values) async {
    final response = await http
        .post(
          Uri.parse('${ApiClient.baseUrl}/api/club_registry.php'),
          headers: await ApiClient.getHeaders(),
          body: jsonEncode(values),
        )
        .timeout(const Duration(seconds: 25));
    await ApiClient.handleUnauthorized(response);
    if (response.statusCode != 201 && response.statusCode != 200) {
      throw Exception(_errorMessage(response, 'Unable to register the club.'));
    }
    dynamic data = _decode(response);
    if (data is Map && data['data'] is Map) data = data['data'];
    if (data is! Map) throw const FormatException('Club creation returned invalid data.');
    return CampusClub.fromJson(
      data.map((key, value) => MapEntry(key.toString(), value)),
    );
  }

  static Future<CampusClub> updateClub(int clubId, Map<String, dynamic> values) async {
    final response = await http
        .put(
          Uri.parse('${ApiClient.baseUrl}/api/club_registry.php/$clubId'),
          headers: await ApiClient.getHeaders(),
          body: jsonEncode(values),
        )
        .timeout(const Duration(seconds: 25));
    await ApiClient.handleUnauthorized(response);
    if (response.statusCode != 200) {
      throw Exception(_errorMessage(response, 'Unable to update the club.'));
    }
    dynamic data = _decode(response);
    if (data is Map && data['data'] is Map) data = data['data'];
    if (data is! Map) throw const FormatException('Club update returned invalid data.');
    return CampusClub.fromJson(
      data.map((key, value) => MapEntry(key.toString(), value)),
    );
  }

  static Future<void> moderateClub(int clubId, String action, {String reason = ''}) async {
    final response = await http
        .patch(
          Uri.parse('${ApiClient.baseUrl}/api/club_registry.php/$clubId'),
          headers: await ApiClient.getHeaders(),
          body: jsonEncode(<String, dynamic>{'action': action, 'reason': reason}),
        )
        .timeout(const Duration(seconds: 20));
    await ApiClient.handleUnauthorized(response);
    if (response.statusCode != 200) {
      throw Exception(_errorMessage(response, 'Unable to update club approval status.'));
    }
  }

  static Future<void> deleteClub(int clubId) async {
    final response = await http
        .delete(
          Uri.parse('${ApiClient.baseUrl}/api/club_registry.php/$clubId'),
          headers: await ApiClient.getHeaders(),
        )
        .timeout(const Duration(seconds: 20));
    await ApiClient.handleUnauthorized(response);
    if (response.statusCode != 200 && response.statusCode != 204) {
      throw Exception(_errorMessage(response, 'Unable to delete the club.'));
    }
  }

  static Future<List<ClubMember>> getMembers(int clubId) async {
    final response = await _get(
      Uri.parse('${ApiClient.baseUrl}/api/club_members.php').replace(
        queryParameters: <String, String>{'club_id': '$clubId'},
      ),
    );
    if (response.statusCode != 200) {
      throw Exception(_errorMessage(response, 'Unable to load club members.'));
    }
    final data = _decode(response);
    final raw = data is Map ? data['data'] : data;
    if (raw is! List) return const <ClubMember>[];
    return raw.whereType<Map>().map((item) {
      return ClubMember.fromJson(
        item.map((key, value) => MapEntry(key.toString(), value)),
      );
    }).toList();
  }

  static Future<ClubMember> addMember(int clubId, Map<String, dynamic> values) async {
    final body = <String, dynamic>{'club_id': clubId, ...values};
    final response = await http
        .post(
          Uri.parse('${ApiClient.baseUrl}/api/club_members.php'),
          headers: await ApiClient.getHeaders(),
          body: jsonEncode(body),
        )
        .timeout(const Duration(seconds: 20));
    await ApiClient.handleUnauthorized(response);
    if (response.statusCode != 201 && response.statusCode != 200) {
      throw Exception(_errorMessage(response, 'Unable to add the club member.'));
    }
    dynamic data = _decode(response);
    if (data is Map && data['data'] is Map) data = data['data'];
    if (data is! Map) throw const FormatException('Member creation returned invalid data.');
    return ClubMember.fromJson(
      data.map((key, value) => MapEntry(key.toString(), value)),
    );
  }

  static Future<ClubMember> updateMember(int memberId, Map<String, dynamic> values) async {
    final response = await http
        .put(
          Uri.parse('${ApiClient.baseUrl}/api/club_members.php/$memberId'),
          headers: await ApiClient.getHeaders(),
          body: jsonEncode(values),
        )
        .timeout(const Duration(seconds: 20));
    await ApiClient.handleUnauthorized(response);
    if (response.statusCode != 200) {
      throw Exception(_errorMessage(response, 'Unable to update the club member.'));
    }
    dynamic data = _decode(response);
    if (data is Map && data['data'] is Map) data = data['data'];
    if (data is! Map) throw const FormatException('Member update returned invalid data.');
    return ClubMember.fromJson(
      data.map((key, value) => MapEntry(key.toString(), value)),
    );
  }

  static Future<void> removeMember(int memberId) async {
    final response = await http
        .delete(
          Uri.parse('${ApiClient.baseUrl}/api/club_members.php/$memberId'),
          headers: await ApiClient.getHeaders(),
        )
        .timeout(const Duration(seconds: 20));
    await ApiClient.handleUnauthorized(response);
    if (response.statusCode != 200 && response.statusCode != 204) {
      throw Exception(_errorMessage(response, 'Unable to remove the club member.'));
    }
  }

  static Future<List<ClubDocument>> getDocuments(int clubId) async {
    final response = await _get(
      Uri.parse('${ApiClient.baseUrl}/api/club_documents.php').replace(
        queryParameters: <String, String>{'club_id': '$clubId'},
      ),
    );
    if (response.statusCode != 200) {
      throw Exception(_errorMessage(response, 'Unable to load club documents.'));
    }
    final data = _decode(response);
    final raw = data is Map ? data['data'] : data;
    if (raw is! List) return const <ClubDocument>[];
    return raw.whereType<Map>().map((item) {
      return ClubDocument.fromJson(
        item.map((key, value) => MapEntry(key.toString(), value)),
      );
    }).toList();
  }

  static Future<List<ClubDocument>> uploadDocuments({
    required int clubId,
    required String documentType,
    required List<ClubLocalDocument> documents,
  }) async {
    if (documents.isEmpty) return const <ClubDocument>[];
    if (documents.length > 5) {
      throw Exception('You can upload at most 5 club documents at once.');
    }

    final request = http.MultipartRequest(
      'POST',
      Uri.parse('${ApiClient.baseUrl}/api/club_documents.php'),
    );
    final headers = await ApiClient.getHeaders();
    headers.remove('Content-Type');
    request.headers.addAll(headers);
    request.fields['club_id'] = '$clubId';
    request.fields['document_type'] = documentType;

    for (final document in documents) {
      final file = File(document.path);
      if (!await file.exists()) {
        throw Exception('${document.name} could not be found. Please select it again.');
      }
      final length = await file.length();
      if (length > 10 * 1024 * 1024) {
        throw Exception('${document.name} is larger than 10 MB.');
      }
      request.files.add(
        await http.MultipartFile.fromPath(
          'documents[]',
          document.path,
          filename: document.name,
        ),
      );
    }

    final streamed = await request.send().timeout(const Duration(seconds: 90));
    final response = await http.Response.fromStream(streamed);
    await ApiClient.handleUnauthorized(response);
    if (response.statusCode != 201 && response.statusCode != 200) {
      throw Exception(_errorMessage(response, 'Unable to upload club documents.'));
    }
    final data = _decode(response);
    final raw = data is Map ? data['data'] : null;
    if (raw is! List) return const <ClubDocument>[];
    return raw.whereType<Map>().map((item) {
      return ClubDocument.fromJson(
        item.map((key, value) => MapEntry(key.toString(), value)),
      );
    }).toList();
  }

  static Future<void> deleteDocument(int documentId) async {
    final response = await http
        .delete(
          Uri.parse('${ApiClient.baseUrl}/api/club_documents.php/$documentId'),
          headers: await ApiClient.getHeaders(),
        )
        .timeout(const Duration(seconds: 20));
    await ApiClient.handleUnauthorized(response);
    if (response.statusCode != 200 && response.statusCode != 204) {
      throw Exception(_errorMessage(response, 'Unable to remove the club document.'));
    }
  }

  static Future<String> downloadDocument(ClubDocument document) async {
    final response = await _get(
      Uri.parse('${ApiClient.baseUrl}/api/club_document_download.php').replace(
        queryParameters: <String, String>{'id': '${document.id}'},
      ),
    );
    if (response.statusCode != 200) {
      throw Exception(_errorMessage(response, 'Unable to download the club document.'));
    }

    Directory? directory;
    try {
      directory = await getDownloadsDirectory();
    } catch (_) {}
    if (directory == null) {
      try {
        directory = await getExternalStorageDirectory();
      } catch (_) {}
    }
    directory ??= await getApplicationDocumentsDirectory();

    final safeName = document.originalName
        .replaceAll(RegExp(r'[\\/:*?"<>|]'), '_')
        .trim();
    final preferredName = safeName.isEmpty ? 'club_document_${document.id}' : safeName;
    var output = File('${directory.path}${Platform.pathSeparator}$preferredName');
    if (await output.exists()) {
      final dot = preferredName.lastIndexOf('.');
      final stamp = DateTime.now().millisecondsSinceEpoch;
      final renamed = dot > 0
          ? '${preferredName.substring(0, dot)}_$stamp${preferredName.substring(dot)}'
          : '${preferredName}_$stamp';
      output = File('${directory.path}${Platform.pathSeparator}$renamed');
    }
    await output.writeAsBytes(response.bodyBytes, flush: true);
    return output.path;
  }

  static Future<void> openDownloadedDocument(String path) async {
    await OpenFilex.open(path);
  }
}
