import React, {useEffect, useState} from 'react';
import {
  View,
  Text,
  TouchableOpacity,
  SafeAreaView,
  StyleSheet,
  TextInput,
  FlatList,
  Keyboard,
  Linking,
  StatusBar,
  TouchableWithoutFeedback,
} from 'react-native';
import {useDispatch, useStore} from 'react-redux';
import {ContactType, ProfilePreviewType, ScreenType} from '../../types';
import {
  handleAddFriend,
  HeaderHeight,
  normalize,
  SCREEN_HEIGHT,
  SCREEN_WIDTH,
} from '../../utils';
import {checkPermission, getAll} from 'react-native-contacts';
import {usersFromContactsService} from '../../services/UserFriendsService';
import {ProfilePreview, TabsGradient} from '../../components';
import Animated from 'react-native-reanimated';
import Icon from 'react-native-vector-icons/Feather';
import {InviteFriendTile} from '../../components/friends';
import {TAGG_LIGHT_BLUE} from '../../constants';
const AnimatedIcon = Animated.createAnimatedComponent(Icon);

interface InviteFriendsScreenProps {
  screenType: ScreenType;
}

const InviteFriendsScreen: React.FC<InviteFriendsScreenProps> = ({
  screenType,
}) => {
  const dispatch = useDispatch();
  const state = useStore().getState();
  const [usersFromContacts, setUsersFromContacts] = useState<
    ProfilePreviewType[]
  >([]);
  const [nonUsersFromContacts, setNonUsersFromContacts] = useState<[]>([]);
  type SearchResultType = {
    usersFromContacts: ProfilePreviewType[];
    nonUsersFromContacts: [];
  };
  const [results, setResults] = useState<SearchResultType>({
    usersFromContacts: usersFromContacts,
    nonUsersFromContacts: nonUsersFromContacts,
  });
  const [query, setQuery] = useState('');

  const extractContacts = async () => {
    let retrievedContacts: Array<ContactType> = [];
    await getAll().then((contacts) => {
      contacts.map((contact) => {
        let obj: ContactType = {
          first_name: contact.givenName,
          last_name: contact.familyName,
        };
        contact.phoneNumbers.map(async (phoneNumber) => {
          obj.phone_number = phoneNumber.number;
          retrievedContacts.push(obj);
          console.log('contact: ', obj);
        });
      });
    });
    return retrievedContacts;
  };

  useEffect(() => {
    const handleFindFriends = () => {
      extractContacts().then(async (retrievedContacts) => {
        const permission = await checkPermission();
        if (permission === 'authorized') {
          let response = await usersFromContactsService(retrievedContacts);
          await setUsersFromContacts(response.existing_tagg_users);
          await setNonUsersFromContacts(response.invite_from_contacts);
          usersFromContacts.map((user) => console.log('user: ', user.username));
          setResults({
            usersFromContacts: response.existing_tagg_users,
            nonUsersFromContacts: response.invite_from_contacts,
          });
        } else {
          Linking.openSettings();
        }
      });
    };
    handleFindFriends();
  }, []);

  /*
   * Main handler for changes in query.
   */
  useEffect(() => {
    const search = async () => {
      if (query.length > 0) {
        const searchResultsUsers = usersFromContacts.filter(
          (item: ProfilePreviewType) => {
            if (
              item.first_name.includes(query) ||
              item.last_name.includes(query) ||
              item.username.includes(query)
            ) {
              return item;
            }
          },
        );
        const searchResultsNonUsers = nonUsersFromContacts.filter((item) => {
          if (item.firstName.includes(query) || item.lastName.includes(query)) {
            return item;
          }
        });
        const sanitizedResult = {
          usersFromContacts: searchResultsUsers,
          nonUsersFromContacts: searchResultsNonUsers,
        };
        setResults(sanitizedResult);
      } else {
        setResults({
          usersFromContacts: usersFromContacts,
          nonUsersFromContacts: nonUsersFromContacts,
        });
      }
    };
    search();
  }, [query]);

  const UsersFromContacts = () => (
    <>
      <FlatList
        style={{maxHeight: SCREEN_HEIGHT * 0.2}}
        showsVerticalScrollIndicator={false}
        data={results.usersFromContacts}
        keyExtractor={(item) => item.username}
        renderItem={({item}) => (
          <View key={item.id} style={styles.ppContainer}>
            <View style={styles.friend}>
              <ProfilePreview
                {...{profilePreview: item}}
                previewType={'Friend'}
                screenType={screenType}
              />
            </View>
            <TouchableOpacity
              style={styles.addFriendButton}
              onPress={() => {
                handleAddFriend(screenType, item, dispatch, state).then(
                  (success) => {
                    if (success) {
                      let users = usersFromContacts;
                      const filteredUsers = users.filter(
                        (user) => user.username !== item.username,
                      );
                      console.log('filteredUsers: ', filteredUsers);
                      setResults({
                        ...results,
                        usersFromContacts: filteredUsers,
                      });
                    }
                  },
                );
              }}>
              <Text style={styles.addFriendButtonTitle}>Add Friend</Text>
            </TouchableOpacity>
          </View>
        )}
      />
    </>
  );

  const NonUsersFromContacts = () => (
    <>
      <FlatList
        contentContainerStyle={{paddingBottom: 130}}
        showsVerticalScrollIndicator={false}
        data={results.nonUsersFromContacts}
        keyExtractor={(item) => item.phoneNumber}
        renderItem={({item}) => <InviteFriendTile item={item} />}
      />
    </>
  );

  return (
    <View style={{backgroundColor: 'white', height: SCREEN_HEIGHT}}>
      <TouchableWithoutFeedback onPress={Keyboard.dismiss}>
        <SafeAreaView>
          <StatusBar barStyle="dark-content" />
          <View style={styles.body}>
            <View style={{width: 319, height: 42, alignSelf: 'center', marginBottom: '2%',}}>
              <Text style={[styles.subheaderText, {textAlign: 'center'}]}>
                Sharing is caring, invite friends, and create moments together!
              </Text>
            </View>
            <View style={styles.container}>
              <Animated.View style={styles.inputContainer}>
                <AnimatedIcon
                  name="search"
                  color={'#7E7E7E'}
                  size={16}
                  style={styles.searchIcon}
                />
                <TextInput
                  style={[styles.input]}
                  placeholderTextColor={'#828282'}
                  clearButtonMode="while-editing"
                  autoCapitalize="none"
                  autoCorrect={false}
                  onChangeText={(text) => {
                    setQuery(text);
                  }}
                  onBlur={() => {
                    Keyboard.dismiss();
                  }}
                  onEndEditing={() => {
                    Keyboard.dismiss();
                  }}
                  value={query}
                  placeholder={'Search'}
                />
              </Animated.View>
            </View>
            <View style={styles.subheader}>
              <Text style={[styles.subheaderText, {marginBottom: '5%'}]}>
                Add Friends
              </Text>
              <UsersFromContacts />
            </View>
            <View style={styles.subheader}>
              <Text style={styles.subheaderText}>Invite your friends!</Text>
              <NonUsersFromContacts />
            </View>
          </View>
        </SafeAreaView>
      </TouchableWithoutFeedback>
      <TabsGradient />
    </View>
  );
};

const styles = StyleSheet.create({
  body: {
    paddingTop: HeaderHeight * 1.3,
    height: SCREEN_HEIGHT * 0.8,
    backgroundColor: '#fff',
  },
  subheader: {
    alignSelf: 'center',
    width: SCREEN_WIDTH * 0.85,
    marginBottom: '5%',
  },
  subheaderText: {
    color: '#828282',
    fontSize: normalize(12),
    fontWeight: '600',
    lineHeight: normalize(14.32),
  },
  container: {
    alignSelf: 'center',
    flexDirection: 'row',
    justifyContent: 'space-between',
    width: '100%',
    height: normalize(42),
    alignItems: 'center',
    marginBottom: '3%',
    marginHorizontal: 10,
  },
  ppContainer: {
    alignSelf: 'center',
    flexDirection: 'row',
    justifyContent: 'space-between',
    width: '100%',
    height: normalize(42),
    alignItems: 'center',
    marginBottom: '5%',
    marginHorizontal: 10,
  },
  inputContainer: {
    flexGrow: 1,
    flexDirection: 'row',
    alignItems: 'center',
    paddingHorizontal: 8,
    marginHorizontal: '3%',
    borderRadius: 20,
    backgroundColor: '#F0F0F0',
    height: 34,
  },
  searchIcon: {
    marginRight: '5%',
  },
  input: {
    flex: 1,
    fontSize: normalize(16),
    color: '#000',
    letterSpacing: normalize(0.5),
  },
  cancelButton: {
    height: '100%',
    position: 'absolute',
    justifyContent: 'center',
    paddingHorizontal: 8,
  },
  cancelText: {
    color: '#818181',
    fontWeight: '500',
  },
  friend: {
    alignSelf: 'center',
    height: '100%',
  },
  addFriendButton: {
    alignSelf: 'center',
    justifyContent: 'center',
    alignItems: 'center',
    width: 82,
    height: 25,
    borderColor: TAGG_LIGHT_BLUE,
    borderWidth: 2,
    borderRadius: 2,
    padding: 0,
    backgroundColor: TAGG_LIGHT_BLUE,
  },
  addFriendButtonTitle: {
    color: 'white',
    padding: 0,
    fontSize: normalize(11),
    fontWeight: '700',
    lineHeight: normalize(13.13),
    letterSpacing: normalize(0.6),
    paddingHorizontal: '3.8%',
  },
});

export default InviteFriendsScreen;
