import { useState, useRef, useEffect, useGlobal, getGlobal } from 'reactn'
import { Pressable, TextInput, View, Image, Text, Keyboard, FlatList } from 'react-native'
import { responsiveHeight } from '../actions/responsiveSizes.js'
import { useDataFromRef } from 'react-native-minuit/src/hooks'
import { useKeyboard } from '@react-native-community/hooks'
import moment from 'moment'

import { Fonts, gutters, Palette } from '../styles'
import Style, { bubbleStyle } from '../styles/Style'

import firebase, { chatsRef } from '../config/firebase'

import { formatNameForConfidentiality } from '../helpers/index.js'
import useLayoutType from '../hooks/useLayoutType.js'

import TypingLoader from './TypingLoader'
import Avatar from './Avatar'
import RenderChatFile from './RenderChatFile.js'
import HyperlinkContainer from './HyperlinkContainer.js'

export default ({
  chatID = null,

  layout = 'default', // default | taskSideBar

  containerStyle = {},
  messageListContainerStyle = {},
}) => {
  const [currentUID] = useGlobal('currentUID')
  const [currentProjectData] = useGlobal('currentProjectData')

  const [isTyping] = useState(false)

  const flatListRef = useRef()

  const { isNative } = useLayoutType()
  const { keyboardShown = false } = useKeyboard()

  const { data: messageList } = useDataFromRef({
    ref: chatID
      ? chatsRef.doc(chatID).collection('messages').orderBy('createdAt', 'desc').limit(50)
      : null,
    simpleRef: false,
    listener: true,
    condition: chatID,
    refreshArray: [chatID],
    documentID: 'messageID',
  })

  let conversation = [
    isTyping ? { senderID: 'minuit.ai', userTyping: true } : null,
    ...(messageList || []),
  ].filter((item) => item)

  if (layout === 'default') {
    conversation = conversation.reverse()
  }

  useEffect(() => {
    if (flatListRef?.current && isNative && keyboardShown) {
      flatListRef?.current?.scrollToEnd?.({ animated: true })
    }
  }, [keyboardShown, isNative])

  return (
    <View
      style={{
        height: responsiveHeight(85, true),
        ...containerStyle,
      }}
    >
      <View style={{ flex: 1, ...messageListContainerStyle }}>
        <FlatList
          ref={flatListRef}
          data={conversation}
          estimatedItemSize={50}
          scrollEnabled
          contentContainerStyle={{
            paddingBottom: responsiveHeight(40),
          }}
          showsVerticalScrollIndicator={false}
          keyExtractor={(item, index) =>
            item?.messageID ? `${item?.messageID?.toString()}-${index}` : `no-messageID-${index}`
          }
          renderItem={({
            item: {
              createdAt = null,
              senderID,
              senderName = '',
              senderProfilePicture = null,
              text = '',
              userTyping = false,
              files = [],
            },
            index,
          }) => {
            const isCurrentUser = senderID === currentUID
            const isChatbot = senderID === 'minuit.ai'

            const senderData = currentProjectData?.teamMembers?.[senderID] || {}

            const isDayChange =
              moment(createdAt?.toDate()).format('DD/MM/YYYY') !==
                moment(conversation[index - 1]?.createdAt?.toDate() || new Date()).format(
                  'DD/MM/YYYY'
                ) || !conversation[index - 1]

            return (
              <>
                {isDayChange && (
                  <View
                    style={{
                      ...Style.containerCenter,
                      marginBottom: gutters / 2,
                    }}
                  >
                    <Text
                      style={{
                        ...Fonts({
                          type: 'default',
                          color: Palette.white,
                          style: { textAlign: 'center', opacity: 0.5 },
                        }),
                      }}
                    >
                      {moment(createdAt?.toDate()).format('[Le] DD/MM/YYYY [à] HH:mm')}
                    </Text>

                    <View
                      style={{
                        ...Style.separatorHorizontal,
                        width: '100%',
                      }}
                    />
                  </View>
                )}

                <View
                  style={[
                    Style.containerRow,
                    {
                      flexDirection: isCurrentUser ? 'row-reverse' : 'row',
                      alignItems: 'flex-end',
                      width: '100%',
                      marginBottom: gutters / 2,
                    },
                  ]}
                >
                  {!isCurrentUser && (
                    <View
                      style={{
                        ...Style.containerRound,
                        ...Style.containerCenter,
                        ...(isCurrentUser
                          ? {
                              marginLeft: gutters / 2,
                              backgroundColor: Palette.primary,
                            }
                          : {
                              marginRight: gutters / 2,
                              backgroundColor: 'transparent',
                              borderColor: Palette.primary,
                              borderWidth: 1,
                            }),
                      }}
                    >
                      <Avatar
                        name={isChatbot ? 'm' : senderData?.name || senderName || ''}
                        url={senderData?.profilePictureURL || senderProfilePicture || null}
                        size={35}
                      />
                    </View>
                  )}

                  <View
                    style={{
                      alignItems: isCurrentUser ? 'flex-end' : 'flex-start',
                    }}
                  >
                    {files?.map((props, index) => (
                      <RenderChatFile
                        key={index}
                        {...props}
                        containerStyle={{
                          marginBottom:
                            index !== files?.length - 1
                              ? gutters / 2
                              : text?.length > 0 || userTyping
                                ? gutters / 2
                                : 0,
                        }}
                      />
                    )) || null}

                    {(text?.length > 0 || userTyping) && (
                      <View
                        style={{
                          ...bubbleStyle({
                            isCurrentUser,
                            customStyle: {
                              marginBottom: files?.length > 0 ? gutters / 2 : 0,
                            },
                          }),
                        }}
                      >
                        {userTyping ? (
                          <TypingLoader />
                        ) : (
                          <HyperlinkContainer>
                            <Text
                              style={Fonts({
                                type: 'default',
                                style: {
                                  color: Palette.white,
                                  textAlign: isCurrentUser ? 'right' : 'left',
                                  width: '100%',
                                },
                              })}
                            >
                              {text}
                            </Text>
                          </HyperlinkContainer>
                        )}
                      </View>
                    )}
                  </View>
                </View>
              </>
            )
          }}
        />
      </View>
    </View>
  )
}

export const onSendMessage = async ({
  chatID = null,
  projectID = null,
  message = '',
  setMessage = () => {},
  setIsTyping = () => {},
  customPayload = {},
}) => {
  try {
    const currentUID = getGlobal()?.currentUID || null
    const { name = '', profilePictureURL = null } = getGlobal()?.currentUserData || {}

    if (message.length > 0 || customPayload?.files?.length > 0) {
      Keyboard.dismiss()
      setMessage('')

      const messageData = {
        projectID,
        createdAt: firebase.firestore.FieldValue.serverTimestamp(),
        senderID: currentUID,
        senderName: formatNameForConfidentiality({ name }),
        senderProfilePicture: profilePictureURL || null,
        text: message,
        ...customPayload,
      }

      await chatsRef.doc(chatID).collection('messages').add(messageData)
    }
  } catch (error) {
    console.log(error)
  } finally {
    setIsTyping(false)
  }
}