import AsyncStorage from '@react-native-community/async-storage';
import {
  ERROR_BADGES_EXCEED_LIMIT,
  ERROR_UPLOAD_BADGES,
} from '../constants/strings';
import {
  ADD_BADGES_ENDPOINT,
  EDIT_PROFILE_ENDPOINT,
  GET_USER_BADGES_ENDPOINT,
  REMOVE_BADGES_ENDPOINT,
  SP_MUTUAL_BADGE_HOLDERS_ENDPOINT,
  SP_UPDATE_PICTURE_ENDPOINT,
  SP_USERS_ENDPOINT,
  UPDATE_BADGES_ENDPOINT,
} from '../constants/api';
import {
  ProfilePreviewType,
  SuggestedPeopleDataType,
  UniversityBadge,
} from '../types';
import {Alert} from 'react-native';

export const sendSuggestedPeopleLinked = async (
  userId: string,
  suggested_people_linked: number,
) => {
  try {
    const request = new FormData();
    request.append('suggested_people_linked', suggested_people_linked);
    const endpoint = EDIT_PROFILE_ENDPOINT + `${userId}/`;
    const token = await AsyncStorage.getItem('token');
    let response = await fetch(endpoint, {
      method: 'PATCH',
      headers: {
        'Content-Type': 'multipart/form-data',
        Authorization: 'Token ' + token,
      },
      body: request,
    });
    return response.status === 200;
  } catch (error) {
    console.log('Error updating animated tutorial close button press');
    return false;
  }
};

export const sendSuggestedPeoplePhoto = async (photoUri: string) => {
  try {
    const token = await AsyncStorage.getItem('token');
    const form = new FormData();
    form.append('suggested_people', {
      uri: photoUri,
      name: 'sp_photo.jpg',
      type: 'image/jpg',
    });
    const response = await fetch(SP_UPDATE_PICTURE_ENDPOINT, {
      method: 'POST',
      headers: {
        'Content-Type': 'multipart/form-data',
        Authorization: 'Token ' + token,
      },
      body: form,
    });
    return response.status === 201;
  } catch (error) {
    console.log('Error uploading SP photo');
    return false;
  }
};

export const getSuggestedPeople = async (
  limit: number,
  offset: number,
  seed: number,
) => {
  try {
    const token = await AsyncStorage.getItem('token');
    const url = `${SP_USERS_ENDPOINT}?limit=${limit}&offset=${offset}&seed=${seed}`;
    const response = await fetch(url, {
      method: 'GET',
      headers: {
        Authorization: 'Token ' + token,
      },
    });
    if (response.status !== 200) {
      throw 'Non-200 response';
    }
    const data = await response.json();
    const typedData: SuggestedPeopleDataType[] = data.results;
    return typedData;
  } catch (error) {
    console.log('Error fetching SP user data');
    console.log(error);
    return [];
  }
};

export const getSuggestedPeopleProfile = async (userId: string) => {
  try {
    const token = await AsyncStorage.getItem('token');
    const response = await fetch(SP_USERS_ENDPOINT + userId + '/', {
      method: 'GET',
      headers: {
        Authorization: 'Token ' + token,
      },
    });
    if (response.status === 200) {
      const data: SuggestedPeopleDataType = await response.json();
      return data;
    } else {
      return undefined;
    }
  } catch (error) {
    console.log('Error retrieving SP info');
    return undefined;
  }
};

export const getMutualBadgeHolders = async (badge_id: string) => {
  try {
    const token = await AsyncStorage.getItem('token');
    console.log('badge_id: ', badge_id);
    const response = await fetch(
      SP_MUTUAL_BADGE_HOLDERS_ENDPOINT + '?badge_id=' + badge_id,
      {
        method: 'GET',
        headers: {
          Authorization: 'Token ' + token,
        },
      },
    );
    if (response.status === 200) {
      const data: ProfilePreviewType[] = await response.json();
      return data;
    } else {
      return undefined;
    }
  } catch (error) {
    console.log('Error retrieving SP info');
    return undefined;
  }
};

export const addBadgesService = async (
  selectedBadges: string[],
  university: string,
) => {
  try {
    const token = await AsyncStorage.getItem('token');
    const form = new FormData();
    form.append('badges', JSON.stringify(selectedBadges));
    form.append('university', JSON.stringify(university));
    const response = await fetch(ADD_BADGES_ENDPOINT, {
      method: 'POST',
      headers: {
        'Content-Type': 'multipart/form-data',
        Authorization: 'Token ' + token,
      },
      body: form,
    });
    if (response.status === 400) {
      Alert.alert(ERROR_BADGES_EXCEED_LIMIT);
      return false;
    }
    return true;
  } catch (error) {
    console.log(error);
    Alert.alert(ERROR_UPLOAD_BADGES);
    return false;
  }
};

export const getBadgesService = async (userId: string) => {
  try {
    const token = await AsyncStorage.getItem('token');
    const response = await fetch(
      GET_USER_BADGES_ENDPOINT + '?user_id=' + userId,
      {
        method: 'GET',
        headers: {
          Authorization: 'Token ' + token,
        },
      },
    );
    if (response.status === 200) {
      const data: UniversityBadge[] = await response.json();
      return data ? data : [];
    } else {
      console.log('Error loading badges data');
      return [];
    }
  } catch (error) {
    console.log('Exception occued while loading badges data, ', error);
    return [];
  }
};

export const updateBadgesService = async (
  selectedBadges: string[],
  university: string,
) => {
  try {
    const token = await AsyncStorage.getItem('token');
    const form = new FormData();
    form.append('badges', JSON.stringify(selectedBadges));
    form.append('university', JSON.stringify(university));
    const response = await fetch(UPDATE_BADGES_ENDPOINT, {
      method: 'POST',
      headers: {
        'Content-Type': 'multipart/form-data',
        Authorization: 'Token ' + token,
      },
      body: form,
    });
    if (response.status === 400) {
      Alert.alert(ERROR_BADGES_EXCEED_LIMIT);
      return false;
    }
    if (response.status === 200) {
      return true;
    }
  } catch (error) {
    console.log(error);
    Alert.alert(ERROR_UPLOAD_BADGES);
  }
};

export const removeBadgesService = async (
  removableBadges: string[],
  userId: string,
) => {
  try {
    const token = await AsyncStorage.getItem('token');
    const form = new FormData();
    form.append('badges', JSON.stringify(removableBadges));
    form.append('user', JSON.stringify(userId));
    const response = await fetch(REMOVE_BADGES_ENDPOINT, {
      method: 'DELETE',
      headers: {
        'Content-Type': 'multipart/form-data',
        Authorization: 'Token ' + token,
      },
      body: form,
    });
    if (response.status === 400) {
      Alert.alert(ERROR_BADGES_EXCEED_LIMIT);
      return false;
    }
    if (response.status === 200) {
      return true;
    }
  } catch (error) {
    console.log(error);
    Alert.alert(ERROR_UPLOAD_BADGES);
    return false;
  }
};