import { API_CONFIG } from '@/config/api';
import httpService, { ApiResponse } from './httpService';

// 球友信息接口
export interface FollowUser {
  id: number;
  nickname: string;
  avatar_url: string;
  personal_profile?: string;
  gender?: string;
  city?: string;
  ntrp_level?: number;
  // 关注状态：mutual_follow=互相关注, following=已关注, follower=粉丝, recommend=推荐
  follow_status: 'mutual_follow' | 'following' | 'follower' | 'recommend';
  follow_time?: string; // 关注时间
  is_mutual?: boolean; // 是否互关
  is_following?: boolean; // 是否已关注
  common_games_count?: number; // 共同参与球局数量
}

// 关注列表响应接口
export interface FollowListResponse {
  list: FollowUser[];
  total: number;
  current_city?: string; // 当前用户城市（推荐接口返回）
}

// 球友关注服务类
export class FollowService {
  
  // 获取互关用户列表
  static async get_mutual_follow_list(
    page: number = 1,
    page_size: number = 20
  ): Promise<FollowListResponse> {
    try {
      const response = await httpService.post<FollowListResponse>(
        '/user_follow/mutual_follow_list', 
        { page, page_size },
        { showLoading: false }
      );

      if (response.code === 0) {
        // 为数据添加 follow_status 标识
        const list = response.data.list.map(user => ({
          ...user,
          follow_status: 'mutual_follow' as const
        }));
        return { ...response.data, list };
      } else {
        throw new Error(response.message || '获取互关列表失败');
      }
    } catch (error) {
      console.error('获取互关列表失败:', error);
      return { list: [], total: 0 };
    }
  }

  // 获取我的粉丝列表
  static async get_fans_list(
    page: number = 1,
    page_size: number = 20
  ): Promise<FollowListResponse> {
    try {
      const response = await httpService.post<FollowListResponse>(
        '/user_follow/my_fans_list', 
        { page, page_size },
        { showLoading: false }
      );

      if (response.code === 0) {
        // 为数据添加 follow_status 标识
        const list = response.data.list.map(user => ({
          ...user,
          follow_status: user.is_mutual ? 'mutual_follow' as const : 'follower' as const
        }));
        return { ...response.data, list };
      } else {
        throw new Error(response.message || '获取粉丝列表失败');
      }
    } catch (error) {
      console.error('获取粉丝列表失败:', error);
      return { list: [], total: 0 };
    }
  }

  // 获取新增粉丝列表（新关注的人）
  static async get_new_fans_list(
    page: number = 1,
    page_size: number = 20
  ): Promise<FollowListResponse> {
    try {
      const response = await httpService.post<FollowListResponse>(
        '/user_follow/new_fans_list', 
        { page, page_size },
        { showLoading: false }
      );

      if (response.code === 0) {
        // 为数据添加 follow_status 标识
        const list = response.data.list.map(user => ({
          ...user,
          follow_status: user.is_mutual ? 'mutual_follow' as const : 'follower' as const
        }));
        return { ...response.data, list };
      } else {
        throw new Error(response.message || '获取新增粉丝列表失败');
      }
    } catch (error) {
      console.error('获取新增粉丝列表失败:', error);
      return { list: [], total: 0 };
    }
  }

  // 获取我的关注列表
  static async get_following_list(
    page: number = 1,
    page_size: number = 20
  ): Promise<FollowListResponse> {
    try {
      const response = await httpService.post<FollowListResponse>(
        '/user_follow/my_following_list', 
        { page, page_size },
        { showLoading: false }
      );

      if (response.code === 0) {
        // 为数据添加 follow_status 标识
        const list = response.data.list.map(user => ({
          ...user,
          follow_status: user.is_mutual ? 'mutual_follow' as const : 'following' as const
        }));
        return { ...response.data, list };
      } else {
        throw new Error(response.message || '获取关注列表失败');
      }
    } catch (error) {
      console.error('获取关注列表失败:', error);
      return { list: [], total: 0 };
    }
  }

  // 获取关注列表（统一入口）
  static async get_follow_list(
    type: 'mutual_follow' | 'following' | 'follower' | 'recommend',
    page: number = 1,
    page_size: number = 20
  ): Promise<FollowListResponse> {
    switch (type) {
      case 'mutual_follow':
        return this.get_mutual_follow_list(page, page_size);
      case 'following':
        return this.get_following_list(page, page_size);
      case 'follower':
        return this.get_fans_list(page, page_size);
      case 'recommend':
        return this.get_recommend_users(page, page_size);
      default:
        return { list: [], total: 0 };
    }
  }

  // 关注用户
  static async follow_user(user_id: number): Promise<boolean> {
    try {
      const response = await httpService.post<any>(
        API_CONFIG.USER.FOLLOW,
        { following_id: user_id },
        {
          showLoading: false,
          loadingText: '关注中...'
        }
      );

      if (response.code === 0) {
        return true;
      } else {
        throw new Error(response.message || '关注失败');
      }
    } catch (error) {
      console.error('关注失败:', error);
      throw error;
    }
  }

  // 取消关注用户
  static async unfollow_user(user_id: number): Promise<boolean> {
    try {
      const response = await httpService.post<any>(
        API_CONFIG.USER.UNFOLLOW,
        { following_id: user_id },
        {
          showLoading: false,
          loadingText: '取消关注中...'
        }
      );

      if (response.code === 0) {
        return true;
      } else {
        throw new Error(response.message || '取消关注失败');
      }
    } catch (error) {
      console.error('取消关注失败:', error);
      throw error;
    }
  }

  // 回关用户（关注粉丝）
  static async follow_back(user_id: number): Promise<boolean> {
    return this.follow_user(user_id);
  }

  // 获取同城推荐用户
  static async get_recommend_users(page: number = 1, page_size: number = 10): Promise<FollowListResponse> {
    try {
      const response = await httpService.post<FollowListResponse>(
        '/user_follow/recommend_same_city',
        { page, page_size },
        { showLoading: false }
      );

      if (response.code === 0) {
        // 为数据添加 follow_status 标识
        const list = response.data.list.map(user => ({
          ...user,
          follow_status: 'recommend' as const
        }));
        return { ...response.data, list };
      } else {
        throw new Error(response.message || '获取推荐用户失败');
      }
    } catch (error) {
      console.error('获取推荐用户失败:', error);
      return { list: [], total: 0 };
    }
  }

  // 检查关注状态
  static async check_follow_status(user_id: number): Promise<'mutual_follow' | 'following' | 'follower' | 'none'> {
    try {
      const response = await httpService.post<{ status: string }>(
        '/wch_users/follow_status',
        { user_id },
        { showLoading: false }
      );

      if (response.code === 0) {
        return response.data.status as 'mutual_follow' | 'following' | 'follower' | 'none';
      } else {
        return 'none';
      }
    } catch (error) {
      console.error('检查关注状态失败:', error);
      return 'none';
    }
  }
}

export default FollowService;