use std::collections::{HashMap, HashSet};
use std::sync::{Arc, OnceLock};
use std::time::Duration;


use anyhow::{anyhow, Result};
use ln_sdk::client::lnd::{LndClient, LndConfig};
use ln_sdk::HttpConfig;
use nostr::{
    message::relay::RelayMessage,
    prelude::{decrypt, ToBech32},
    Event, EventBuilder, Filter, Keys, Profile, Url,

            .iter()
            .map(|o| o.metadata(composite_params_opt))
            .collect(),
    );

    // Bot keys are known and valid
    info!("nostr_bot pubkey: {}", nostr_bot_keys.public_key());
    nostr_bot_status.set_bot_pk(nostr_bot_keys.public_key());

    // Expect owner keys
    nostr_bot_status.to_state_pending_owner_key_pairing()?;

    // Retrieve bot owner profile
    match composite_params_opt
        .try_get_bot_owner_nprofile_with_nip65_relays()
        .await?
    {
        None => {
            warn!("Bot owner profile not configured");
            Ok(None)
        }
        Some(owner_profile) => {
            // Owner key is known and valid
            info!("nostr_bot_owner profile: {owner_profile:?}");
            info!("nostr_bot_owner nprofile: {}", owner_profile.to_bech32()?);
            nostr_bot_status.set_owner_pk(owner_profile.public_key);

            // Collect all relays we want to connect to
            let mut relevant_relays: HashSet<String> = HashSet::new();
            for relay in &owner_profile.relays {
                relevant_relays.insert(relay.clone());
            }
            if composite_params_opt.ons4.enabled {

}

/// True, if the bot already sent a greeting message to this owner pubkey. False otherwise.
///
/// If the owner changes pubkeys, the new one will also receive a greeting when its paired.
async fn was_last_greeting_sent_this_pubkey(
    db: &mut PoolConnection<Sqlite>,
    owner_pk_hex: &str,
) -> bool {
    db::config::config_read_optional(db, KEY_GREETING_SENT)
        .await
        .map_err(|e| error!("Error when trying to read config from DB: {:?}", e))
        .map(|greeted_key| match greeted_key {
            None => false,
            Some(k) => k.eq(owner_pk_hex),
        })
        .unwrap_or(false)
}

async fn set_last_greeting_sent_this_pubkey(db: &mut PoolConnection<Sqlite>, owner_pk_hex: &str) {
    info!("Marking owner pubkey as greeted");
    db::config::config_write_or_update(db, KEY_GREETING_SENT, owner_pk_hex)
        .await
        .map_err(|e| error!("Error when trying to write config to DB: {:?}", e))
        .unwrap();
}

async fn maybe_greet_user(db: &mut PoolConnection<Sqlite>, ctx: &mut NostrContext) {
    let owner_pk_hex: String = ctx
        .nostr_bot_owner_nprofile
        .public_key
        .serialize()
        .encode_hex();
    if !was_last_greeting_sent_this_pubkey(db, &owner_pk_hex).await {
        info!("Sending greeting to pubkey {owner_pk_hex}");

        ctx.send(GREETING.to_string()).await;

        set_last_greeting_sent_this_pubkey(db, &owner_pk_hex).await;
    }
}

use crate::model::api::ApiError::GenericError;
use crate::model::api::ApiErrorLogged;
use crate::model::bot::nostr::NostrBotState::*;
use anyhow::{anyhow, Result};
use hex::ToHex;
use nostr::secp256k1::XOnlyPublicKey;
use nostr::ToBech32;
use serde::{Deserialize, Serialize};
use std::sync::{Arc, Mutex};
use utoipa::ToSchema;

/// Current status of the deltachat bot submodule
#[derive(Clone, Serialize, ToSchema)]
pub struct NostrBotStatus {
    #[schema(value_type = NostrBotState)]
    pub(crate) state: Arc<Mutex<NostrBotState>>,

    #[schema(value_type = String)]
    pub(crate) bot_pk_hex: Arc<Mutex<Option<String>>>,

    #[schema(value_type = String)]
    pub(crate) bot_pk_npub: Arc<Mutex<Option<String>>>,

    #[schema(value_type = String)]
    pub(crate) owner_pk_hex: Arc<Mutex<Option<String>>>,

    #[schema(value_type = String)]
    pub(crate) owner_pk_npub: Arc<Mutex<Option<String>>>,

    #[schema(value_type = OnsMetadata)]
    pub(crate) ons: Arc<Mutex<Vec<OnsMetadata>>>,
}

impl NostrBotStatus {
    pub(crate) fn ensure_nip47_module_enabled(&self) -> Result<(), ApiErrorLogged> {

    pub enabled: bool,
}

impl Default for NostrBotStatus {
    fn default() -> NostrBotStatus {
        NostrBotStatus {
            state: Arc::new(Mutex::new(PendingBotKeySetup)),
            bot_pk_hex: Arc::new(Mutex::new(None)),
            bot_pk_npub: Arc::new(Mutex::new(None)),
            owner_pk_hex: Arc::new(Mutex::new(None)),
            owner_pk_npub: Arc::new(Mutex::new(None)),
            ons: Arc::new(Mutex::new(vec![])),
        }
    }
}

pub trait NostrBotStatusOps {
    fn set_bot_pk(&self, bot_pk: XOnlyPublicKey);
    fn set_owner_pk(&self, owner_pk: XOnlyPublicKey);
    fn set_ons(&self, ons: Vec<OnsMetadata>);
}

impl NostrBotStatusOps for NostrBotStatus {
    fn set_bot_pk(&self, bot_pk: XOnlyPublicKey) {
        let mut locked_bot_pk_hex = self.bot_pk_hex.lock().unwrap();
        *locked_bot_pk_hex = Some(bot_pk.serialize().encode_hex());

        let mut locked_bot_pk_npub = self.bot_pk_npub.lock().unwrap();
        *locked_bot_pk_npub = Some(bot_pk.to_bech32().unwrap());
    }

    fn set_owner_pk(&self, owner_pk: XOnlyPublicKey) {
        let mut locked_owner_pk_hex = self.owner_pk_hex.lock().unwrap();
        *locked_owner_pk_hex = Some(owner_pk.serialize().encode_hex());

        let mut locked_owner_pk_npub = self.owner_pk_npub.lock().unwrap();
        *locked_owner_pk_npub = Some(owner_pk.to_bech32().unwrap());
    }

    fn set_ons(&self, ons: Vec<OnsMetadata>) {
        let mut mutex_ons = self.ons.lock().unwrap();
        *mutex_ons = ons;
    }
}

  }

  function show_nostr_connect_qr(nwc_secret) {

    $.ajax( "/status" )
      .done(function(data) {
        let bot_pk = data.nostr_bot.bot_pk_hex;
        let relay_best = data.relay_best;
        let nostr_connect_string = "nostr+walletconnect://" + bot_pk + "?relay=" + relay_best + "&secret=" + nwc_secret;

        console.log("Showing QR for NWC connection string: " + nostr_connect_string);
        show_qr(nostr_connect_string);
      });
  }

              <i class="bi bi-check-circle-fill"></i>
              The bot is up and running
            </div>
          </div>

          <div>
            Your pubkey:
            <p class="card-text font-monospace fs-6 py-2" id="owner-pk-npub"></p>

            Bot pubkey:
            <p class="card-text font-monospace fs-6 py-2" id="bot-pk-npub"></p>

            <div class="card-text">
              <button type="button" class="btn btn-primary btn-sm ms-auto" data-bs-toggle="modal" data-bs-target="#modal-setup-owner-pk-relay">Update pairing</button>
            </div>
          </div>

        </div>

        <div class="modal-header">
          <h5 class="modal-title">Setup Bot Pairing</h5>
          <button type="button" class="btn-close" data-bs-dismiss="modal" aria-label="Close"></button>
        </div>
        <div class="modal-body">
          <form>
            <div class="mb-3">
              <label for="owner-pk-input" class="col-form-label">Your Nostr Pubkey:</label>
              <input type="text" class="form-control" id="owner-pk-input" placeholder="npub.." autofocus>
            </div>
            <div class="mb-3">
              <label for="owner-relay-input" class="col-form-label">One relay where you post:</label>
              <input type="text" class="form-control" id="owner-relay-input" placeholder="wss://...">
            </div>
          </form>
        </div>

          if (currentBotState == "StartupError") {
            alert(currentBotState);
            $('#card-StartupError').show();
          }
          else if (currentBotState == "Running") {
            $('#card-Running').show();

            $("#bot-pk-npub").text(responseJsonObj.nostr_bot.bot_pk_npub);
            $("#owner-pk-npub").text(responseJsonObj.nostr_bot.owner_pk_npub);

            var relay_data = [];
            for (var r in responseJsonObj.relays) {
              relay_data.push(
                {
                  'id': r,
                  'status': responseJsonObj.relays[r]

    function persist_pk_relay() {
      var addModal = document.getElementById('modal-setup-owner-pk-relay');

      let postObj = {
          pk_hex_or_npub: addModal.querySelector('#owner-pk-input').value,
          relay: addModal.querySelector('#owner-relay-input').value
      }

      $.ajax({
        type: "post",
        url: "/bot/nostr",
        data: JSON.stringify(postObj),