import 'package:get/get.dart';
import 'package:flutter_smart_dialog/flutter_smart_dialog.dart';
import '../../network/home_api.dart';
import '../../model/home/marriage_data.dart';

class HomeController extends GetxController {
  // 推荐列表数据
  final recommendFeed = <MarriageData>[].obs;
  // 同城列表数据
  final nearbyFeed = <MarriageData>[].obs;
  
  // 推荐列表的加载状态和分页信息
  final recommendIsLoading = false.obs;
  final recommendPage = 1.obs;
  final recommendHasMore = true.obs;
  
  // 同城列表的加载状态和分页信息
  final nearbyIsLoading = false.obs;
  final nearbyPage = 1.obs;
  final nearbyHasMore = true.obs;
  
  // 当前标签页索引
  final selectedTabIndex = 0.obs;
  
  // 分页大小
  final pageSize = 10;

  // 从GetX依赖注入中获取HomeApi实例
  late final HomeApi _homeApi;

  @override
  void onInit() {
    super.onInit();
    // 从全局依赖中获取HomeApi
    _homeApi = Get.find<HomeApi>();
    // 初始化时加载数据
    loadInitialData();
  }

  /// 加载初始数据（同时加载两个标签页的数据）
  void loadInitialData() async {
    // 并行加载两个标签页的数据
    await Future.wait([
      loadRecommendInitialData(),
      loadNearbyInitialData(),
    ]);
  }
  
  /// 加载推荐列表初始数据
  Future<void> loadRecommendInitialData() async {
    if (recommendIsLoading.value) return;
    
    try {
      recommendIsLoading.value = true;
      recommendPage.value = 1;
      recommendHasMore.value = true;
      
      // 获取推荐数据 (type=0)
      final List<MarriageData> items = await _fetchMarriageData(
        page: 1,
        type: 0,
      );
      
      // 重置并更新推荐列表
      recommendFeed.clear();
      recommendFeed.addAll(items);
      
      // 根据实际获取的数据量判断是否还有更多数据
      recommendHasMore.value = items.length >= pageSize;
    } catch (e) {
      _handleError('获取推荐列表异常', e, '推荐列表加载失败，请稍后重试');
    } finally {
      recommendIsLoading.value = false;
    }
  }
  
  /// 加载同城列表初始数据
  Future<void> loadNearbyInitialData() async {
    if (nearbyIsLoading.value) return;
    
    try {
      nearbyIsLoading.value = true;
      nearbyPage.value = 1;
      nearbyHasMore.value = true;
      
      // 获取同城数据 (type=1)
      final List<MarriageData> items = await _fetchMarriageData(
        page: 1,
        type: 1,
      );
      
      // 重置并更新同城列表
      nearbyFeed.clear();
      nearbyFeed.addAll(items);
      
      // 根据实际获取的数据量判断是否还有更多数据
      nearbyHasMore.value = items.length >= pageSize;
    } catch (e) {
      _handleError('获取同城列表异常', e, '同城列表加载失败，请稍后重试');
    } finally {
      nearbyIsLoading.value = false;
    }
  }

  /// 加载更多数据
  Future<void> loadMoreData([int? tabIndex]) async {
    final targetTab = tabIndex ?? selectedTabIndex.value;
    
    if (targetTab == 0) {
      // 加载推荐列表更多数据
      await loadRecommendMoreData();
    } else {
      // 加载同城列表更多数据
      await loadNearbyMoreData();
    }
  }
  
  /// 加载推荐列表更多数据
  Future<void> loadRecommendMoreData() async {
    if (recommendIsLoading.value || !recommendHasMore.value) return;
    
    try {
      recommendIsLoading.value = true;
      recommendPage.value++;
      
      // 获取推荐数据 (type=0)
      final List<MarriageData> items = await _fetchMarriageData(
        page: recommendPage.value,
        type: 0,
      );
      
      // 更新推荐列表
      recommendFeed.addAll(items);
      
      // 根据实际获取的数据量判断是否还有更多数据
      recommendHasMore.value = items.length >= pageSize;
    } catch (e) {
      recommendPage.value--; // 回退页码
      _handleError('加载推荐更多异常', e, '加载更多失败');
    } finally {
      recommendIsLoading.value = false;
    }
  }
  
  /// 加载同城列表更多数据
  Future<void> loadNearbyMoreData() async {
    if (nearbyIsLoading.value || !nearbyHasMore.value) return;
    
    try {
      nearbyIsLoading.value = true;
      nearbyPage.value++;
      
      // 获取同城数据 (type=1)
      final List<MarriageData> items = await _fetchMarriageData(
        page: nearbyPage.value,
        type: 1,
      );
      
      // 更新同城列表
      nearbyFeed.addAll(items);
      
      // 根据实际获取的数据量判断是否还有更多数据
      nearbyHasMore.value = items.length >= pageSize;
    } catch (e) {
      nearbyPage.value--; // 回退页码
      _handleError('加载同城更多异常', e, '加载更多失败');
    } finally {
      nearbyIsLoading.value = false;
    }
  }

  /// 刷新数据
  Future<void> refreshData([int? tabIndex]) async {
    final targetTab = tabIndex ?? selectedTabIndex.value;
    
    if (targetTab == 0) {
      // 刷新推荐列表
      await refreshRecommendData();
    } else {
      // 刷新同城列表
      await refreshNearbyData();
    }
  }
  
  /// 刷新推荐列表数据
  Future<void> refreshRecommendData() async {
    if (recommendIsLoading.value) return;
    
    try {
      recommendIsLoading.value = true;
      recommendPage.value = 1;
      recommendHasMore.value = true;
      
      // 获取推荐数据 (type=0)
      final List<MarriageData> items = await _fetchMarriageData(
        page: 1,
        type: 0,
      );
      
      // 更新推荐列表
      recommendFeed.clear();
      recommendFeed.addAll(items);
      
      // 根据实际获取的数据量判断是否还有更多数据
      recommendHasMore.value = items.length >= pageSize;
    } catch (e) {
      _handleError('刷新推荐数据异常', e, '刷新失败，请稍后重试');
    } finally {
      recommendIsLoading.value = false;
    }
  }
  
  /// 刷新同城列表数据
  Future<void> refreshNearbyData() async {
    if (nearbyIsLoading.value) return;
    
    try {
      nearbyIsLoading.value = true;
      nearbyPage.value = 1;
      nearbyHasMore.value = true;
      
      // 获取同城数据 (type=1)
      final List<MarriageData> items = await _fetchMarriageData(
        page: 1,
        type: 1,
      );
      
      // 更新同城列表
      nearbyFeed.clear();
      nearbyFeed.addAll(items);
      
      // 根据实际获取的数据量判断是否还有更多数据
      nearbyHasMore.value = items.length >= pageSize;
    } catch (e) {
      _handleError('刷新同城数据异常', e, '刷新失败，请稍后重试');
    } finally {
      nearbyIsLoading.value = false;
    }
  }

  /// 设置当前标签页
  void setSelectedTabIndex(int index) {
    print('Setting selected tab index to: $index');
    selectedTabIndex.value = index;
    // 确保UI能够更新
    update();
  }

  /// 获取当前标签页的列表数据
  List<MarriageData> getFeedListByTab(int tabIndex) {
    return tabIndex == 0 ? List.from(recommendFeed) : List.from(nearbyFeed);
  }

  /// 私有方法：获取婚姻数据（统一的数据获取逻辑）
  Future<List<MarriageData>> _fetchMarriageData({
    required int page,
    required int type,
  }) async {
    try {
      // 调用API获取数据
      var response = await _homeApi.getMarriageList(
        page: page,
        pageSize: pageSize,
        type: type,
      );

      if (response.data.isSuccess && response.data.data != null) {
        // 根据API返回结构解析数据
        final data = response.data.data;
        
        // 检查data是否包含列表数据
        if (data is List) {
          // 如果data直接是列表，直接映射为MarriageData
          return data.map((item) => MarriageData.fromJson(item as Map<String, dynamic>)).toList();
        } else if (data is Map<String, dynamic>) {
          // 如果data是对象，检查是否有list或records字段
          final listData = data['list'] ?? data['records'];
          if (listData is List) {
            return listData.map((item) => MarriageData.fromJson(item as Map<String, dynamic>)).toList();
          }
        }
        
        // 如果无法解析为有效列表，返回空列表
        return [];
      } else {
        // 响应失败，抛出异常
        throw Exception(response.data.message ?? '获取数据失败');
      }
    } catch (e) {
      // 向上抛出异常，让调用方处理
      rethrow;
    }
  }

  /// 私有方法：统一的错误处理
  void _handleError(String logMessage, dynamic error, String toastMessage) {
    // 打印错误日志
    print('$logMessage: $error');
    // 显示错误提示
    SmartDialog.showToast(toastMessage);
  }
}