use crate::*;
use Color::*;

/// A clip, rendered as a horizontal piano roll.
#[derive(Clone)]
pub struct PianoHorizontal {
    pub clip: Option<Arc<RwLock<MidiClip>>>,
    /// Buffer where the whole clip is rerendered on change
    pub buffer: Arc<RwLock<BigBuffer>>,
    /// Size of actual notes area
    pub size:   Measure<TuiOut>,
    /// The display window
    pub range:  MidiRangeModel,
    /// The note cursor
    pub point:  MidiPointModel,
    /// The highlight color palette
    pub color:  ItemTheme,
    /// Width of the keyboard
    pub keys_width: u16,
}

impl PianoHorizontal {
    pub fn new (clip: Option<&Arc<RwLock<MidiClip>>>) -> Self {
        let size = Measure::new();
        let mut range  = MidiRangeModel::from((12, true));
        range.time_axis = size.x.clone();
        range.note_axis = size.y.clone();
        let piano = Self {
            keys_width: 5,
            size,
            range,
            buffer: RwLock::new(Default::default()).into(),
            point:  MidiPointModel::default(),
            clip: clip.cloned(),
            color: clip.as_ref().map(|p|p.read().unwrap().color).unwrap_or(ItemTheme::G[64]),
        };
        piano.redraw();
        piano
    }
}

pub(crate) fn note_y_iter (note_lo: usize, note_hi: usize, y0: u16) -> impl Iterator<Item=(usize, u16, usize)> {
    (note_lo..=note_hi).rev().enumerate().map(move|(y, n)|(y, y0 + y as u16, n))
}

content!(TuiOut:|self: PianoHorizontal| Tui::bg(Tui::g(40), Bsp::s(
    Bsp::e(
        Fixed::x(5, format!("{}x{}", self.size.w(), self.size.h())),
        self.timeline()
    ),
    Bsp::e(
        self.keys(),
        self.size.of(Tui::bg(Tui::g(32), Bsp::b(
            Fill::xy(self.notes()),
            Fill::xy(self.cursor()),
        )))
    ),
)));

impl PianoHorizontal {
    /// Draw the piano roll background.
    ///
    /// This mode uses full blocks on note on and half blocks on legato: █▄ █▄ █▄
    fn draw_bg (buf: &mut BigBuffer, clip: &MidiClip, zoom: usize, note_len: usize) {
        for (y, note) in (0..=127).rev().enumerate() {
            for (x, time) in (0..buf.width).map(|x|(x, x*zoom)) {
                let cell = buf.get_mut(x, y).unwrap();
                cell.set_bg(clip.color.darkest.rgb);
                if time % 384 == 0 {
                    cell.set_fg(clip.color.darker.rgb);
                    cell.set_char('│');
                } else if time % 96 == 0 {
                    cell.set_fg(clip.color.dark.rgb);
                    cell.set_char('╎');
                } else if time % note_len == 0 {
                    cell.set_fg(clip.color.darker.rgb);
                    cell.set_char('┊');
                } else if (127 - note) % 12 == 0 {
                    cell.set_fg(clip.color.darker.rgb);
                    cell.set_char('=');
                } else if (127 - note) % 6 == 0 {
                    cell.set_fg(clip.color.darker.rgb);
                    cell.set_char('—');
                } else {
                    cell.set_fg(clip.color.darker.rgb);
                    cell.set_char('·');
                }
            }
        }
    }
    /// Draw the piano roll foreground.
    ///
    /// This mode uses full blocks on note on and half blocks on legato: █▄ █▄ █▄
    fn draw_fg (buf: &mut BigBuffer, clip: &MidiClip, zoom: usize) {
        let style = Style::default().fg(clip.color.base.rgb);//.bg(Rgb(0, 0, 0));
        let mut notes_on = [false;128];
        for (x, time_start) in (0..clip.length).step_by(zoom).enumerate() {
            for (_y, note) in (0..=127).rev().enumerate() {
                if let Some(cell) = buf.get_mut(x, note) {
                    if notes_on[note] {
                        cell.set_char('▂');
                        cell.set_style(style);
                    }
                }
            }
            let time_end = time_start + zoom;
            for time in time_start..time_end.min(clip.length) {
                for event in clip.notes[time].iter() {
                    match event {
                        MidiMessage::NoteOn { key, .. } => {
                            let note = key.as_int() as usize;
                            if let Some(cell) = buf.get_mut(x, note) {
                                cell.set_char('█');
                                cell.set_style(style);
                            }
                            notes_on[note] = true
                        },
                        MidiMessage::NoteOff { key, .. } => {
                            notes_on[key.as_int() as usize] = false
                        },
                        _ => {}
                    }
                }
            }

        }
    }
    fn notes (&self) -> impl Content<TuiOut> {
        let time_start = self.time_start().get();
        let note_lo    = self.note_lo().get();
        let note_hi    = self.note_hi();
        let buffer     = self.buffer.clone();
        ThunkRender::new(move|to: &mut TuiOut|{
            let source = buffer.read().unwrap();
            let [x0, y0, w, _h] = to.area().xywh();
            //if h as usize != note_axis {
                //panic!("area height mismatch: {h} <> {note_axis}");
            //}
            for (area_x, screen_x) in (x0..x0+w).enumerate() {
                for (area_y, screen_y, _note) in note_y_iter(note_lo, note_hi, y0) {
                    let source_x = time_start + area_x;
                    let source_y = note_hi    - area_y;
                    // TODO: enable loop rollover:
                    //let source_x = (time_start + area_x) % source.width.max(1);
                    //let source_y = (note_hi    - area_y) % source.height.max(1);
                    let is_in_x = source_x < source.width;
                    let is_in_y = source_y < source.height;
                    if is_in_x && is_in_y {
                        if let Some(source_cell) = source.get(source_x, source_y) {
                            if let Some(cell) = to.buffer.cell_mut(ratatui::prelude::Position::from((screen_x, screen_y))) {
                                *cell = source_cell.clone();
                            }
                        }
                    }
                }
            }
        })
    }
    fn cursor (&self) -> impl Content<TuiOut> {
        let style = Some(Style::default().fg(self.color.lightest.rgb));
        let note_hi = self.note_hi();
        let note_lo = self.note_lo().get();
        let note_pos = self.note_pos();
        let note_len = self.note_len();
        let time_pos = self.time_pos();
        let time_start = self.time_start().get();
        let time_zoom  = self.time_zoom().get();
        ThunkRender::new(move|to: &mut TuiOut|{
            let [x0, y0, w, _] = to.area().xywh();
            for (_area_y, screen_y, note) in note_y_iter(note_lo, note_hi, y0) {
                if note == note_pos {
                    for x in 0..w {
                        let screen_x = x0 + x;
                        let time_1 = time_start + x as usize * time_zoom;
                        let time_2 = time_1 + time_zoom;
                        if time_1 <= time_pos && time_pos < time_2 {
                            to.blit(&"█", screen_x, screen_y, style);
                            let tail = note_len as u16 / time_zoom as u16;
                            for x_tail in (screen_x + 1)..(screen_x + tail) {
                                to.blit(&"▂", x_tail, screen_y, style);
                            }
                            break
                        }
                    }
                    break
                }
            }
        })
    }
    fn keys (&self) -> impl Content<TuiOut> {
        let state      = self;
        let color      = state.color;
        let note_lo    = state.note_lo().get();
        let note_hi    = state.note_hi();
        let note_pos = state.note_pos();
        let key_style  = Some(Style::default().fg(Rgb(192, 192, 192)).bg(Rgb(0, 0, 0)));
        let off_style  = Some(Style::default().fg(Tui::g(255)));
        let on_style   = Some(Style::default().fg(Rgb(255,0,0)).bg(color.base.rgb).bold());
        Fill::y(Fixed::x(self.keys_width, ThunkRender::new(move|to: &mut TuiOut|{
            let [x, y0, _w, _h] = to.area().xywh();
            for (_area_y, screen_y, note) in note_y_iter(note_lo, note_hi, y0) {
                to.blit(&to_key(note), x, screen_y, key_style);
                if note > 127 {
                    continue
                }
                if note == note_pos {
                    to.blit(&format!("{:<5}", Note::pitch_to_name(note)), x, screen_y, on_style)
                } else {
                    to.blit(&Note::pitch_to_name(note), x, screen_y, off_style)
                };
            }
        })))
    }
    fn timeline (&self) -> impl Content<TuiOut> + '_ {
        Fill::x(Fixed::y(1, ThunkRender::new(move|to: &mut TuiOut|{
            let [x, y, w, _h] = to.area();
            let style = Some(Style::default().dim());
            let length = self.clip.as_ref().map(|p|p.read().unwrap().length).unwrap_or(1);
            for (area_x, screen_x) in (0..w).map(|d|(d, d+x)) {
                let t = area_x as usize * self.time_zoom().get();
                if t < length {
                    to.blit(&"|", screen_x, y, style);
                }
            }
        })))
    }
}

has_size!(<TuiOut>|self:PianoHorizontal|&self.size);

impl TimeRange for PianoHorizontal {
    fn time_len   (&self) -> &AtomicUsize { self.range.time_len()   }
    fn time_zoom  (&self) -> &AtomicUsize { self.range.time_zoom()  }
    fn time_lock  (&self) -> &AtomicBool  { self.range.time_lock()  }
    fn time_start (&self) -> &AtomicUsize { self.range.time_start() }
    fn time_axis  (&self) -> &AtomicUsize { self.range.time_axis()  }
}

impl NoteRange for PianoHorizontal {
    fn note_lo    (&self) -> &AtomicUsize { self.range.note_lo()    }
    fn note_axis  (&self) -> &AtomicUsize { self.range.note_axis()  }
}

impl NotePoint for PianoHorizontal {
    fn note_len (&self) -> usize { self.point.note_len() }
    fn set_note_len (&self, x: usize) -> usize { self.point.set_note_len(x) }
    fn note_pos (&self) -> usize { self.point.note_pos() }
    fn set_note_pos (&self, x: usize) -> usize { self.point.set_note_pos(x) }
}

impl TimePoint for PianoHorizontal {
    fn time_pos (&self) -> usize { self.point.time_pos() }
    fn set_time_pos (&self, x: usize) -> usize { self.point.set_time_pos(x) }
}

impl MidiViewer for PianoHorizontal {
    fn clip (&self) -> &Option<Arc<RwLock<MidiClip>>> {
        &self.clip
    }
    fn clip_mut (&mut self) -> &mut Option<Arc<RwLock<MidiClip>>> {
        &mut self.clip
    }
    /// Determine the required space to render the clip.
    fn buffer_size (&self, clip: &MidiClip) -> (usize, usize) {
        (clip.length / self.range.time_zoom().get(), 128)
    }
    fn redraw (&self) {
        *self.buffer.write().unwrap() = if let Some(clip) = self.clip.as_ref() {
            let clip       = clip.read().unwrap();
            let buf_size   = self.buffer_size(&clip);
            let mut buffer = BigBuffer::from(buf_size);
            let note_len   = self.note_len();
            let time_zoom  = self.time_zoom().get();
            self.time_len().set(clip.length);
            PianoHorizontal::draw_bg(&mut buffer, &clip, time_zoom, note_len);
            PianoHorizontal::draw_fg(&mut buffer, &clip, time_zoom);
            buffer
        } else {
            Default::default()
        }
    }
    fn set_clip (&mut self, clip: Option<&Arc<RwLock<MidiClip>>>) {
        *self.clip_mut() = clip.cloned();
        self.color = clip.map(|p|p.read().unwrap().color)
            .unwrap_or(ItemTheme::G[64]);
        self.redraw();
    }
}

impl std::fmt::Debug for PianoHorizontal {
    fn fmt (&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
        let buffer = self.buffer.read().unwrap();
        f.debug_struct("PianoHorizontal")
            .field("time_zoom", &self.range.time_zoom)
            .field("buffer", &format!("{}x{}", buffer.width, buffer.height))
            .finish()
    }
}
        // Update sequencer playhead indicator
        //self.now().set(0.);
        //if let Some((ref started_at, Some(ref playing))) = self.player.play_clip {
            //let clip = clip.read().unwrap();
            //if *playing.read().unwrap() == *clip {
                //let pulse = self.current().pulse.get();
                //let start = started_at.pulse.get();
                //let now   = (pulse - start) % clip.length as f64;
                //self.now().set(now);
            //}
        //}

fn to_key (note: usize) -> &'static str {
    match note % 12 {
        11 => "████▌",
        10 => "     ",
        9  => "████▌",
        8  => "     ",
        7  => "████▌",
        6  => "     ",
        5  => "████▌",
        4  => "████▌",
        3  => "     ",
        2  => "████▌",
        1  => "     ",
        0  => "████▌",
        _  => unreachable!(),
    }
}

pub struct OctaveVertical {
    on:     [bool; 12],
    colors: [Color; 3]
}

impl Default for OctaveVertical {
    fn default () -> Self {
        Self {
            on:     [false; 12],
            colors: [Rgb(255,255,255), Rgb(0,0,0), Rgb(255,0,0)]
        }
    }
}

impl OctaveVertical {
    fn color (&self, pitch: usize) -> Color {
        let pitch = pitch % 12;
        self.colors[if self.on[pitch] { 2 } else {
            match pitch { 0 | 2 | 4 | 5 | 6 | 8 | 10 => 0, _ => 1 }
        }]
    }
}

impl Content<TuiOut> for OctaveVertical {
    fn content (&self) -> impl Render<TuiOut> {
        row!(
            Tui::fg_bg(self.color(0),  self.color(1),  "▙"),
            Tui::fg_bg(self.color(2),  self.color(3),  "▙"),
            Tui::fg_bg(self.color(4),  self.color(5),  "▌"),
            Tui::fg_bg(self.color(6),  self.color(7),  "▟"),
            Tui::fg_bg(self.color(8),  self.color(9),  "▟"),
            Tui::fg_bg(self.color(10), self.color(11), "▟"),
        )
    }
}