import 'websocket-polyfill'
import { SSMClient, GetParameterCommand, PutParameterCommand } from '@aws-sdk/client-ssm'
import { extract } from '@extractus/feed-extractor'
import NDK, { NDKEvent, NDKPrivateKeySigner } from '@nostr-dev-kit/ndk'
import bech32 from 'bech32-buffer'

const toHexString = nsec => {
    let buffer = bech32.decode(nsec).data
    return buffer.reduce((s, byte) => {
        let hex = byte.toString(16);
        if (hex.length === 1) hex = '0' + hex;
        return s + hex;
    }, '');
}
    

export const handler = async (event) => {
    const region = process.env.AWS_REGION || "us-east-1"
    const feed = event.feedUrl
    const privkey = toHexString(event.nostrNsec)
    const lastRunTimeParam = event.lastRunTimeParam

    let response = {
        totalItems: 0,
        successes: 0,
        errors: []
    }

    const ssmClient = new SSMClient({ region })
    const params = {
        Name: lastRunTimeParam 
    }
    const ssmGetCommand = new GetParameterCommand(params);

    let since = ""
    ssmClient.send(ssmGetCommand)
        .then(data => {
            since = data.Parameter.Value
        }).catch(err => {
            console.error(err)
            response.errors.push(err)
            return response
        })
    

    if (feed === "") {
        console.error("feedUrl was not set.")
        return {
            statusCode: 400,
            body: "feedUrl must be provided in payload."
        }
    }
    
    const ndk = new NDK({
        signer: new NDKPrivateKeySigner(privkey),
        explicitRelayUrls: [
            "wss://nostr.mom",
            "wss://nostr.snort.social",
            "wss://nostr.lol"
        ]
    })
    const user = await ndk.signer.user()

    for (let url of user.relayUrls) {
        ndk.pool.relays.push(url)
    }

    await ndk.connect(6000).catch(err => {
        console.error(err)
        response.errors.push ("failed to connect to relay", err)
    })

    let rss = await extract(feed)
        .catch(err => {
            console.error(err.error);
            return response
        })

    let filtered = rss.entries.filter(item => Date.parse(item.published) >= Date.parse(since))
    response.totalItems = filtered.length

    for (let item of filtered) {
        let ndkEvent = new NDKEvent(ndk, {
            kind: 1,
            pubkey: user.hexpubkey,
            content: item.title,
            created_at: Math.floor(Date.now() / 1000),
        })

        try {
            const published = await ndkEvent.publish()
            if (published) {
                response.successes++
            }
        } catch(e) {
            console.error(e)
            response.errors.push(e)
        }
    }

    params.Name = lastRunTimeParam
    params.Value = new Date().toISOString()
    params.Type = "String"
    params.Overwrite = true

    const ssmPutCommand = new PutParameterCommand(params)
    ssmClient.send(ssmPutCommand)
        .catch(err => {
            console.error(err)
            response.errors.push(err)
            return response
        })

    return response
}