use std::collections::HashMap;
use std::sync::Arc;
use std::time::Duration;
use midir::MidiOutput;

use tokio::sync::{ mpsc, Mutex };
use tokio::time::Instant;
use serde::Deserialize;
use std::thread::sleep;

use crate::loggerbridge::Logger;
pub struct MidiMessage {
  pub message: Vec<u8>,
  pub instant: Instant,
  pub offset: u64,
  pub requestedport: String,
}

pub struct AsyncInputTransmit {
  pub inner: Mutex<mpsc::Sender<Vec<MidiMessage>>>,
}

pub fn init(
  logger: Logger,
  async_input_receiver: mpsc::Receiver<Vec<MidiMessage>>,
  mut async_output_receiver: mpsc::Receiver<Vec<MidiMessage>>,
  async_output_transmitter: mpsc::Sender<Vec<MidiMessage>>
) {
  tauri::async_runtime::spawn(async move { async_process_model(async_input_receiver, async_output_transmitter).await });
  let message_queue: Arc<Mutex<Vec<MidiMessage>>> = Arc::new(Mutex::new(Vec::new()));
  /* ...........................................................
         Listen For incoming messages and add to queue
  ............................................................*/
  let message_queue_clone = Arc::clone(&message_queue);
  tauri::async_runtime::spawn(async move {
    loop {
      if let Some(package) = async_output_receiver.recv().await {
        let mut message_queue = message_queue_clone.lock().await;
        let messages = package;
        for message in messages {
          (*message_queue).push(message);
        }
      }
    }
  });

  let message_queue_clone = Arc::clone(&message_queue);
  tauri::async_runtime::spawn(async move {
    /* ...........................................................
                        Open Midi Ports
    ............................................................*/
    let midiout = MidiOutput::new("strudel").unwrap();
    let out_ports = midiout.ports();
    let mut port_names = Vec::new();
    //TODO: Send these print messages to the UI logger instead of the rust console so the user can see them
    if out_ports.len() == 0 {
      logger.log(
        " No MIDI devices found. Connect a device or enable IAC Driver to enable midi.".to_string(),
        "".to_string()
      );
      // logger(window, " No MIDI devices found. Connect a device or enable IAC Driver.".to_string(), None);
      return;
    }
    // give the frontend couple seconds to load on start, or the log messages will get lost
    sleep(Duration::from_secs(3));
    logger.log(format!("Found {} midi devices!", out_ports.len()), "".to_string());

    // the user could reference any port at anytime during runtime,
    // so let's go ahead and open them all (same behavior as web app)
    let mut output_connections = HashMap::new();
    for i in 0..=out_ports.len().saturating_sub(1) {
      let midiout = MidiOutput::new("strudel").unwrap();
      let ports = midiout.ports();
      let port = ports.get(i).unwrap();
      let port_name = midiout.port_name(port).unwrap();
      logger.log(port_name.clone(), "".to_string());
      let out_con = midiout.connect(port, &port_name).unwrap();
      port_names.insert(i, port_name.clone());
      output_connections.insert(port_name, out_con);
    }
    /* ...........................................................
                        Process queued messages 
    ............................................................*/

    loop {
      let mut message_queue = message_queue_clone.lock().await;

      //iterate over each message, play and remove messages when they are ready
      message_queue.retain(|message| {
        if message.instant.elapsed().as_millis() < message.offset.into() {
          return true;
        }
        let mut out_con = output_connections.get_mut(&message.requestedport);

        // WebMidi supports getting a connection by part of its name
        // ex: 'bus 1' instead of 'IAC Driver bus 1' so let's emulate that behavior
        if out_con.is_none() {
          let key = port_names.iter().find(|port_name| {
            return port_name.contains(&message.requestedport);
          });
          if key.is_some() {
            out_con = output_connections.get_mut(key.unwrap());
          }
        }

        if out_con.is_some() {
          // process the message
          if let Err(err) = (&mut out_con.unwrap()).send(&message.message) {
            logger.log(format!("Midi message send error: {}", err), "error".to_string());
          }
        } else {
          logger.log(format!("failed to find midi device: {}", message.requestedport), "error".to_string());
        }
        return false;
      });

      sleep(Duration::from_millis(1));
    }
  });
}

pub async fn async_process_model(
  mut input_reciever: mpsc::Receiver<Vec<MidiMessage>>,
  output_transmitter: mpsc::Sender<Vec<MidiMessage>>
) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
  while let Some(input) = input_reciever.recv().await {
    let output = input;
    output_transmitter.send(output).await?;
  }
  Ok(())
}
#[derive(Deserialize)]
pub struct MessageFromJS {
  message: Vec<u8>,
  offset: u64,
  requestedport: String,
}
// Called from JS
#[tauri::command]
pub async fn sendmidi(
  messagesfromjs: Vec<MessageFromJS>,
  state: tauri::State<'_, AsyncInputTransmit>
) -> Result<(), String> {
  let async_proc_input_tx = state.inner.lock().await;
  let mut messages_to_process: Vec<MidiMessage> = Vec::new();

  for m in messagesfromjs {
    let message_to_process = MidiMessage {
      instant: Instant::now(),
      message: m.message,
      offset: m.offset,
      requestedport: m.requestedport,
    };
    messages_to_process.push(message_to_process);
  }

  async_proc_input_tx.send(messages_to_process).await.map_err(|e| e.to_string())
}