import got from "got"
import { Boom } from "@hapi/boom"
import { SocketConfig, MediaConnInfo, AnyMessageContent, MiscMessageGenerationOptions, WAMediaUploadFunction, MessageRelayOptions } from "../Types"
import { encodeWAMessage, generateMessageID, generateWAMessage, encryptSenderKeyMsgSignalProto, encryptSignalProto, extractDeviceJids, jidToSignalProtocolAddress, parseAndInjectE2ESessions } from "../Utils"
import { BinaryNode, getBinaryNodeChild, getBinaryNodeChildren, isJidGroup, jidDecode, jidEncode, jidNormalizedUser, S_WHATSAPP_NET, BinaryNodeAttributes, JidWithDevice, reduceBinaryNodeToDictionary } from '../WABinary'
import { proto } from "../../WAProto"
import { WA_DEFAULT_EPHEMERAL, DEFAULT_ORIGIN, MEDIA_PATH_MAP } from "../Defaults"
import { makeGroupsSocket } from "./groups"
import NodeCache from "node-cache"

export const makeMessagesSocket = (config: SocketConfig) => {
	const { logger } = config
	const sock = makeGroupsSocket(config)
	const { 
		ev,
        authState,
        query,
        generateMessageTag,
		sendNode,
        groupMetadata,
        groupToggleEphemeral
	} = sock

    const userDevicesCache = config.userDevicesCache || new NodeCache({
        stdTTL: 300, // 5 minutes
        useClones: false
    })
    let privacySettings: { [_: string]: string } | undefined

    const fetchPrivacySettings = async(force: boolean = false) => {
        if(!privacySettings || force) {
            const result = await query({
                tag: 'iq',
                attrs: {
                    xmlns: 'privacy', 
                    to: S_WHATSAPP_NET, 
                    type: 'get'
                },
                content: [
                    { tag: 'privacy', attrs: { } }
                ]
            })
            privacySettings = reduceBinaryNodeToDictionary(result, 'category')
        }
        return privacySettings
    }

    let mediaConn: Promise<MediaConnInfo>
    const refreshMediaConn = async(forceGet = false) => {
        let media = await mediaConn
        if (!media || forceGet || (new Date().getTime()-media.fetchDate.getTime()) > media.ttl*1000) {
			mediaConn = (async() => {
				const result = await query({
                    tag: 'iq',
                    attrs: {
                        type: 'set',
                        xmlns: 'w:m',
                        to: S_WHATSAPP_NET,
                    },
                    content: [ { tag: 'media_conn', attrs: { } } ]
                })
                const mediaConnNode = getBinaryNodeChild(result, 'media_conn')
                const node: MediaConnInfo = {
                    hosts: getBinaryNodeChildren(mediaConnNode, 'host').map(
                        item => item.attrs as any
                    ),
                    auth: mediaConnNode.attrs.auth,
                    ttl: +mediaConnNode.attrs.ttl,
                    fetchDate: new Date()
                }
                logger.debug('fetched media conn')
				return node
			})()
        }
        return mediaConn
    }

    const sendReceipt = async(jid: string, participant: string | undefined, messageIds: string[], type: 'read' | 'read-self' | undefined) => {
        const node: BinaryNode = {
            tag: 'receipt',
            attrs: {
                id: messageIds[0],
                t: Date.now().toString(),
                to: jid,
            },
        }
        if(type) {
            node.attrs.type = type
        }
        if(participant) {
            node.attrs.participant = participant
        }
        const remainingMessageIds = messageIds.slice(1)
        if(remainingMessageIds.length) {
            node.content = [
                {
                    tag: 'list',
                    attrs: { },
                    content: remainingMessageIds.map(id => ({
                        tag: 'item',
                        attrs: { id }
                    }))
                }
            ]
        }

        logger.debug({ jid, messageIds }, 'reading messages')
        await sendNode(node)
    }

    const sendDeliveryReceipt = (jid: string, participant: string | undefined, messageIds: string[]) => {
        return sendReceipt(jid, participant, messageIds, undefined)
    }

    const sendReadReceipt = async(jid: string, participant: string | undefined, messageIds: string[]) => {
        const privacySettings = await fetchPrivacySettings()
        // based on privacy settings, we have to change the read type
        const readType = privacySettings.readreceipts === 'all' ? 'read' : 'read-self'
        return sendReceipt(jid, participant, messageIds, readType)
    }

    const getUSyncDevices = async(jids: string[], ignoreZeroDevices: boolean) => {
        const deviceResults: JidWithDevice[] = []
       
        const users: BinaryNode[] = []
        jids = Array.from(new Set(jids))
        for(let jid of jids) {
            const user = jidDecode(jid).user
            jid = jidNormalizedUser(jid)
            if(userDevicesCache.has(user)) {
                const devices: JidWithDevice[] = userDevicesCache.get(user)
                deviceResults.push(...devices)

                logger.trace({ user }, 'using cache for devices')
            } else {
                users.push({ tag: 'user', attrs: { jid } })
            }
        }

        const iq: BinaryNode = {
            tag: 'iq',
            attrs: {
                to: S_WHATSAPP_NET,
                type: 'get',
                xmlns: 'usync',
            },
            content: [
                {
                    tag: 'usync',
                    attrs: {
                        sid: generateMessageTag(),
                        mode: 'query',
                        last: 'true',
                        index: '0',
                        context: 'message',
                    },
                    content: [
                        {
                            tag: 'query',
                            attrs: { },
                            content: [
                                { 
                                    tag: 'devices', 
                                    attrs: { version: '2' }
                                }
                            ]
                        },
                        { tag: 'list', attrs: { }, content: users }
                    ]
                },
            ],
        }
        const result = await query(iq)
        const extracted = extractDeviceJids(result, authState.creds.me!.id, ignoreZeroDevices)
        const deviceMap: { [_: string]: JidWithDevice[] } = {}

        for(const item of extracted) {
            deviceMap[item.user] = deviceMap[item.user] || []
            deviceMap[item.user].push(item)

            deviceResults.push(item)
        }

        for(const key in deviceMap) {
            userDevicesCache.set(key, deviceMap[key])
        }

        return deviceResults
    }

    const assertSessions = async(jids: string[], force: boolean) => {
        let jidsRequiringFetch: string[] = []
        if(force) {
            jidsRequiringFetch = jids 
        } else {
            const addrs = jids.map(jid => jidToSignalProtocolAddress(jid).toString())
            const sessions = await authState.keys.get('session', addrs)
            for(const jid of jids) {
                const signalId = jidToSignalProtocolAddress(jid).toString()
                if(!sessions[signalId]) {
                    jidsRequiringFetch.push(jid)
                }
            }
        }

        if(jidsRequiringFetch.length) {
            logger.debug({ jidsRequiringFetch }, `fetching sessions`)
            const result = await query({
                tag: 'iq',
                attrs: {
                    xmlns: 'encrypt',
                    type: 'get',
                    to: S_WHATSAPP_NET,
                },
                content: [
                    {
                        tag: 'key',
                        attrs: { },
                        content: jidsRequiringFetch.map(
                            jid => ({
                                tag: 'user',
                                attrs: { jid, reason: 'identity' },
                            })
                        )
                    }
                ]
            })
            await parseAndInjectE2ESessions(result, authState)
            return true
        }
        return false
    }

    const createParticipantNodes = async(jids: string[], bytes: Buffer) => {
        await assertSessions(jids, false)

        if(authState.keys.isInTransaction()) {
            await authState.keys.prefetch(
                'session', 
                jids.map(jid => jidToSignalProtocolAddress(jid).toString())
            )
        }
        
        const nodes = await Promise.all(
            jids.map(
                async jid => {
                    const { type, ciphertext } = await encryptSignalProto(jid, bytes, authState)
                    const node: BinaryNode = {
                        tag: 'to',
                        attrs: { jid },
                        content: [{
                            tag: 'enc',
                            attrs: { v: '2', type },
                            content: ciphertext
                        }]
                    }
                    return node
                }
            )
        )
        return nodes
    }

    const relayMessage = async(
        jid: string, 
        message: proto.IMessage, 
        { messageId: msgId, participant, additionalAttributes, cachedGroupMetadata }: MessageRelayOptions
    ) => {
        const meId = authState.creds.me!.id

        const { user, server } = jidDecode(jid)
        const isGroup = server === 'g.us'
        msgId = msgId || generateMessageID()

        const encodedMsg = encodeWAMessage(message)
        const participants: BinaryNode[] = []

        const destinationJid = jidEncode(user, isGroup ? 'g.us' : 's.whatsapp.net')

        const binaryNodeContent: BinaryNode[] = []

        const devices: JidWithDevice[] = []
        if(participant) {
            const { user, device } = jidDecode(participant)
            devices.push({ user, device })
        }

        await authState.keys.transaction(
            async() => {
                if(isGroup) {
                    const { ciphertext, senderKeyDistributionMessageKey } = await encryptSenderKeyMsgSignalProto(destinationJid, encodedMsg, meId, authState)
                    
                    const [groupData, senderKeyMap] = await Promise.all([
                        (async() => {
                            let groupData = cachedGroupMetadata ? await cachedGroupMetadata(jid) : undefined 
                            if(!groupData) groupData = await groupMetadata(jid)
                            return groupData
                        })(),
                        (async() => {
                            const result = await authState.keys.get('sender-key-memory', [jid])
                            return result[jid] || { }
                        })()
                    ])
        
                    if(!participant) {
                        const participantsList = groupData.participants.map(p => p.id)
                        const additionalDevices = await getUSyncDevices(participantsList, false)
                        devices.push(...additionalDevices)
                    }
        
                    const senderKeyJids: string[] = []
                    // ensure a connection is established with every device
                    for(const {user, device} of devices) {
                        const jid = jidEncode(user, 's.whatsapp.net', device)
                        if(!senderKeyMap[jid]) {
                            senderKeyJids.push(jid)
                            // store that this person has had the sender keys sent to them
                            senderKeyMap[jid] = true
                        }
                    }
                    // if there are some participants with whom the session has not been established
                    // if there are, we re-send the senderkey
                    if(senderKeyJids.length) {
                        logger.debug({ senderKeyJids }, 'sending new sender key')
        
                        const encSenderKeyMsg = encodeWAMessage({
                            senderKeyDistributionMessage: {
                                axolotlSenderKeyDistributionMessage: senderKeyDistributionMessageKey,
                                groupId: destinationJid
                            }
                        })
        
                        participants.push(
                            ...(await createParticipantNodes(senderKeyJids, encSenderKeyMsg))
                        )
                    }
        
                    binaryNodeContent.push({
                        tag: 'enc',
                        attrs: { v: '2', type: 'skmsg' },
                        content: ciphertext
                    })
        
                    await authState.keys.set({ 'sender-key-memory': { [jid]: senderKeyMap } })
                } else {
                    const { user: meUser } = jidDecode(meId)
                    
                    const encodedMeMsg = encodeWAMessage({
                        deviceSentMessage: {
                            destinationJid,
                            message
                        }
                    })
        
                    if(!participant) {
                        devices.push({ user })
                        devices.push({ user: meUser })
                        
                        const additionalDevices = await getUSyncDevices([ meId, jid ], true)
                        devices.push(...additionalDevices)
                    }
        
                    const meJids: string[] = []
                    const otherJids: string[] = []
                    for(const { user, device } of devices) {
                        const jid = jidEncode(user, 's.whatsapp.net', device)
                        const isMe = user === meUser
                        if(isMe) meJids.push(jid)
                        else otherJids.push(jid)
                    }
        
                    const [meNodes, otherNodes] = await Promise.all([
                        createParticipantNodes(meJids, encodedMeMsg),
                        createParticipantNodes(otherJids, encodedMsg)
                    ])
                    participants.push(...meNodes)
                    participants.push(...otherNodes)
                }
        
                if(participants.length) {
                    binaryNodeContent.push({
                        tag: 'participants',
                        attrs: { },
                        content: participants
                    })
                }
        
                const stanza: BinaryNode = {
                    tag: 'message',
                    attrs: {
                        id: msgId,
                        type: 'text',
                        to: destinationJid,
                        ...(additionalAttributes || {})
                    },
                    content: binaryNodeContent
                }
                
                const shouldHaveIdentity = !!participants.find(
                    participant => (participant.content! as BinaryNode[]).find(n => n.attrs.type === 'pkmsg')
                )
        
                if(shouldHaveIdentity) {
                    (stanza.content as BinaryNode[]).push({
                        tag: 'device-identity',
                        attrs: { },
                        content: proto.ADVSignedDeviceIdentity.encode(authState.creds.account).finish()
                    })
        
                    logger.debug({ jid }, 'adding device identity')
                }
        
                logger.debug({ msgId }, `sending message to ${participants.length} devices`)
        
                await sendNode(stanza)
            }
        )

        return msgId
    } 

    const waUploadToServer: WAMediaUploadFunction = async(stream, { mediaType, fileEncSha256B64, timeoutMs }) => {
		// send a query JSON to obtain the url & auth token to upload our media
		let uploadInfo = await refreshMediaConn(false)

		let mediaUrl: string
        const hosts = [ ...config.customUploadHosts, ...uploadInfo.hosts.map(h => h.hostname) ]
		for (let hostname of hosts) {
			const auth = encodeURIComponent(uploadInfo.auth) // the auth token
			const url = `https://${hostname}${MEDIA_PATH_MAP[mediaType]}/${fileEncSha256B64}?auth=${auth}&token=${fileEncSha256B64}`
			
			try {
				const {body: responseText} = await got.post(
					url, 
					{
						headers: { 
							'Content-Type': 'application/octet-stream',
							'Origin': DEFAULT_ORIGIN
						},
						agent: {
							https: config.agent
						},
						body: stream,
                        timeout: timeoutMs
					}
				)
				const result = JSON.parse(responseText)
				mediaUrl = result?.url
				
				if (mediaUrl) break
				else {
					uploadInfo = await refreshMediaConn(true)
					throw new Error(`upload failed, reason: ${JSON.stringify(result)}`)
				}
			} catch (error) {
				const isLast = hostname === hosts[uploadInfo.hosts.length-1]
				logger.debug(`Error in uploading to ${hostname} (${error}) ${isLast ? '' : ', retrying...'}`)
			}
		}
		if (!mediaUrl) {
			throw new Boom(
				'Media upload failed on all hosts',
				{ statusCode: 500 }
			)
		}
		return { mediaUrl }
	}

	return {
		...sock,
        assertSessions,
        relayMessage,
        sendDeliveryReceipt,
        sendReadReceipt,
        refreshMediaConn,
	    waUploadToServer,
        fetchPrivacySettings,
        sendMessage: async(
			jid: string,
			content: AnyMessageContent,
			options: MiscMessageGenerationOptions = { }
		) => {
            const userJid = authState.creds.me!.id
			if(
				typeof content === 'object' &&
				'disappearingMessagesInChat' in content &&
				typeof content['disappearingMessagesInChat'] !== 'undefined' &&
				isJidGroup(jid)
			) {
				const { disappearingMessagesInChat } = content
				const value = typeof disappearingMessagesInChat === 'boolean' ? 
						(disappearingMessagesInChat ? WA_DEFAULT_EPHEMERAL : 0) :
						disappearingMessagesInChat
                await groupToggleEphemeral(jid, value)
			} else {
				const fullMsg = await generateWAMessage(
					jid,
					content,
					{
						...options,
						logger,
						userJid,
                        // multi-device does not have this yet
						//getUrlInfo: generateUrlInfo,
						upload: waUploadToServer,
                        mediaCache: config.mediaCache,
					}
				)
                const isDeleteMsg = 'delete' in content && !!content.delete
                const additionalAttributes: BinaryNodeAttributes = { }
                // required for delete
                if(isDeleteMsg) {
                    additionalAttributes.edit = '7'
                }

				await relayMessage(jid, fullMsg.message, { messageId: fullMsg.key.id!, additionalAttributes })
                if(config.emitOwnEvents) {
                    process.nextTick(() => {
                        ev.emit('messages.upsert', { messages: [fullMsg], type: 'append' })
                    })
                }
				return fullMsg
			}
        }
	}
}