use crate::*;

#[tengri_proc::expose]
impl Arrangement {
    fn _todo_usize_stub_ (&self) -> usize { todo!() }
    fn _todo_arc_str_stub_ (&self) -> Arc<str> { todo!() }
    fn _todo_item_theme_stub (&self) -> ItemTheme { todo!() }
    fn _todo_opt_item_theme_stub (&self) -> Option<ItemTheme> { todo!() }
    fn _todo_opt_selection_ (&self) -> Option<Selection> { todo!() }
}

#[tengri_proc::command(Arrangement)] 
impl ArrangementCommand {
    /// Set the selection
    fn select (arranger: &mut Arrangement, s: Option<Selection>) -> Perhaps<Self> {
        arranger.selected = s;
        Ok(None)
    }
    /// Launch a clip or scene
    fn launch (arranger: &mut Arrangement) -> Perhaps<Self> {
        use Selection::*;
        match arranger.selected {
            Some(Track(t)) => {
                arranger.tracks[t].sequencer.enqueue_next(None)
            },
            Some(TrackClip { track, scene }) => {
                arranger.tracks[track].sequencer.enqueue_next(arranger.scenes[scene].clips[track].as_ref())
            },
            Some(Scene(s)) => {
                for t in 0..arranger.tracks.len() {
                    arranger.tracks[t].sequencer.enqueue_next(arranger.scenes[s].clips[t].as_ref())
                }
            },
            _ => {}
        };
        Ok(None)
    }
    /// Set the color of the selected entity
    fn set_color (arranger: &mut Arrangement, palette: Option<ItemTheme>) -> Option<ItemTheme> {
        use Selection::*;
        let palette = palette.unwrap_or_else(||ItemTheme::random());
        Some(match arranger.selected {
            Some(Mix) => {
                let old = arranger.color;
                arranger.color = palette;
                old
            },
            Some(Scene(s)) => {
                let old = arranger.scenes[s].color;
                arranger.scenes[s].color = palette;
                old
            }
            Some(Track(t)) => {
                let old = arranger.tracks[t].color;
                arranger.tracks[t].color = palette;
                old
            }
            Some(TrackClip { track, scene }) => {
                if let Some(ref clip) = arranger.scenes[scene].clips[track] {
                    let mut clip = clip.write().unwrap();
                    let old = clip.color;
                    clip.color = palette;
                    old
                } else {
                    return None
                }
            },
            _ => todo!()
        })
    }

    fn track (arranger: &mut Arrangement, track: TrackCommand) -> Perhaps<Self> {
        todo!("delegate")
    }
    fn track_add (arranger: &mut Arrangement) -> Perhaps<Self> {
        let index = arranger.track_add(None, None, &[], &[])?.0;
        arranger.selected = match arranger.selected {
            Some(Selection::Track(_)) =>
                Some(Selection::Track(index)),
            Some(Selection::TrackClip { track, scene }) =>
                Some(Selection::TrackClip { track: index, scene }),
            _ => arranger.selected
        };
        Ok(Some(Self::TrackDelete { index }))
    }
    fn track_swap (arranger: &mut Arrangement, index: usize, other: usize) -> Perhaps<Self> {
        todo!();
        Ok(Some(Self::TrackSwap { index, other }))
    }
    fn track_delete (arranger: &mut Arrangement, index: usize) -> Perhaps<Self> {
        let exists = arranger.tracks().get(index).is_some();
        if exists {
            let track = arranger.tracks_mut().remove(index);
            let Track { sequencer: Sequencer { midi_ins, midi_outs, .. }, .. } = track;
            for port in midi_ins.into_iter() {
                port.close()?;
            }
            for port in midi_outs.into_iter() {
                port.close()?;
            }
            for scene in arranger.scenes_mut().iter_mut() {
                scene.clips.remove(index);
            }
        }
        Ok(None)
        //TODO:Ok(Some(Self::TrackAdd ( index, track: Some(deleted_track) })
    }
    fn midi_in (arranger: &mut Arrangement, input: MidiInputCommand) -> Perhaps<Self> {
        todo!("delegate")
    }
    fn midi_in_add (arranger: &mut Arrangement) -> Perhaps<Self> {
        arranger.midi_in_add()?;
        Ok(None)
    }
    fn midi_out (arranger: &mut Arrangement, input: MidiOutputCommand) -> Perhaps<Self> {
        todo!("delegate")
    }
    fn midi_out_add (arranger: &mut Arrangement) -> Perhaps<Self> {
        arranger.midi_out_add()?;
        Ok(None)
    }
    fn device (arranger: &mut Arrangement, input: DeviceCommand) -> Perhaps<Self> {
        todo!("delegate")
    }
    fn device_add (arranger: &mut Arrangement, i: usize) -> Perhaps<Self> {
        arranger.device_add(i);
        Ok(None)
    }
    fn scene (arranger: &mut Arrangement, scene: SceneCommand) -> Perhaps<Self> {
        todo!("delegate")
    }
    fn scene_add (arranger: &mut Arrangement) -> Perhaps<Self> {
        let index = arranger.scene_add(None, None)?.0;
        arranger.selected = match arranger.selected {
            Some(Selection::Scene(_)) =>
                Some(Selection::Scene(index)),
            Some(Selection::TrackClip { track, scene }) =>
                Some(Selection::TrackClip { track, scene: index }),
            _ => arranger.selected
        };
        Ok(None) // TODO
    }
    fn scene_swap (arranger: &mut Arrangement, index: usize, other: usize) -> Perhaps<Self> {
        todo!();
        Ok(Some(Self::SceneSwap { index, other }))
    }
    fn scene_delete (arranger: &mut Arrangement, index: usize) -> Perhaps<Self> {
        let scenes = arranger.scenes_mut();
        Ok(if scenes.get(index).is_some() {
            let _scene = scenes.remove(index);
            None
        } else {
            None
        })
    }
    fn scene_launch (arranger: &mut Arrangement, index: usize) -> Perhaps<Self> {
        for track in 0..arranger.tracks.len() {
            let clip = arranger.scenes[index].clips[track].as_ref();
            arranger.tracks[track].sequencer.enqueue_next(clip);
        }
        Ok(None)
    }
    fn clip (arranger: &mut Arrangement, scene: ClipCommand) -> Perhaps<Self> {
        todo!("delegate")
    }
    fn clip_get (arranger: &mut Arrangement, a: usize, b: usize) -> Perhaps<Self> {
        //(Get      [a: usize, b: usize]          cmd_todo!("\n\rtodo: clip: get: {a} {b}"))
            //("get"     [a: usize, b: usize] Some(Self::Get(a.unwrap(), b.unwrap())))
        todo!()
    }
    fn clip_put (arranger: &mut Arrangement, a: usize, b: usize) -> Perhaps<Self> {
        //(Put      [t: usize, s: usize, c: MaybeClip]
            //Some(Self::Put(t, s, arranger.clip_put(t, s, c))))
            //("put"     [a: usize, b: usize, c: MaybeClip] Some(Self::Put(a.unwrap(), b.unwrap(), c.unwrap())))
        todo!()
    }
    fn clip_del (arranger: &mut Arrangement, a: usize, b: usize) -> Perhaps<Self> {
        //("delete"  [a: usize, b: usize] Some(Self::Put(a.unwrap(), b.unwrap(), None))))
        todo!()
    }
    fn clip_enqueue (arranger: &mut Arrangement, a: usize, b: usize) -> Perhaps<Self> {
        //(Enqueue  [t: usize, s: usize]
            //cmd!(arranger.tracks[t].sequencer.enqueue_next(arranger.scenes[s].clips[t].as_ref())))
            //("enqueue" [a: usize, b: usize] Some(Self::Enqueue(a.unwrap(), b.unwrap())))
        todo!()
    }
    fn clip_edit (arranger: &mut Arrangement, a: usize, b: usize) -> Perhaps<Self> {
        //(Edit     [clip: MaybeClip]             cmd_todo!("\n\rtodo: clip: edit: {clip:?}"))
            //("edit"    [a: MaybeClip] Some(Self::Edit(a.unwrap())))
        todo!()
    }
}

impl<'state> Context<'state, MidiInputCommand> for Arrangement {
    fn get <'source> (&'state self, iter: &mut TokenIter<'source>) -> Option<MidiInputCommand> {
        Context::get(&self, iter)
    }
}

impl<'state> Context<'state, MidiOutputCommand> for Arrangement {
    fn get <'source> (&'state self, iter: &mut TokenIter<'source>) -> Option<MidiOutputCommand> {
        Context::get(&self, iter)
    }
}

impl<'state> Context<'state, DeviceCommand> for Arrangement {
    fn get <'source> (&'state self, iter: &mut TokenIter<'source>) -> Option<DeviceCommand> {
        Context::get(&self, iter)
    }
}