use crate::*;

/// Contains state for viewing and editing a phrase
pub struct PhraseEditor<E: Engine> {
    _engine:       PhantomData<E>,
    /// Phrase being played
    pub phrase:    Option<Arc<RwLock<Phrase>>>,
    /// Length of note that will be inserted, in pulses
    pub note_len:  usize,
    /// The full piano keys are rendered to this buffer
    pub keys:      Buffer,
    /// The full piano roll is rendered to this buffer
    pub buffer:    BigBuffer,
    /// Cursor/scroll/zoom in pitch axis
    pub note_axis: RwLock<FixedAxis<usize>>,
    /// Cursor/scroll/zoom in time axis
    pub time_axis: RwLock<ScaledAxis<usize>>,
    /// Whether this widget is focused
    pub focused:   bool,
    /// Whether note enter mode is enabled
    pub entered:   bool,
    /// Display mode
    pub mode:      bool,
    /// Notes currently held at input
    pub notes_in:  Arc<RwLock<[bool; 128]>>,
    /// Notes currently held at output
    pub notes_out: Arc<RwLock<[bool; 128]>>,
    /// Current position of global playhead
    pub now:       Arc<Pulse>,
    /// Width of notes area at last render
    pub width:     AtomicUsize,
    /// Height of notes area at last render
    pub height:    AtomicUsize,
}

impl Content for PhraseEditor<Tui> {
    type Engine = Tui;
    fn content (&self) -> impl Widget<Engine = Tui> {
        let Self { focused, entered, keys, phrase, buffer, note_len, .. } = self;
        let FixedAxis {
            start: note_start, point: note_point, clamp: note_clamp
        } = *self.note_axis.read().unwrap();
        let ScaledAxis {
            start: time_start, point: time_point, clamp: time_clamp, scale: time_scale
        } = *self.time_axis.read().unwrap();
        //let color = Color::Rgb(0,255,0);
        //let color = phrase.as_ref().map(|p|p.read().unwrap().color.base.rgb).unwrap_or(color);
        let keys = CustomWidget::new(|to:[u16;2]|Ok(Some(to.clip_w(5))), move|to: &mut TuiOutput|{
            Ok(if to.area().h() >= 2 {
                to.buffer_update(to.area().set_w(5), &|cell, x, y|{
                    let y = y + (note_start / 2) as u16;
                    if x < keys.area.width && y < keys.area.height {
                        *cell = keys.get(x, y).clone()
                    }
                });
            })
        }).fill_y();
        let notes_bg_null = Color::Rgb(28, 35, 25);
        let notes = CustomWidget::new(|to|Ok(Some(to)), move|to: &mut TuiOutput|{
            let area = to.area();
            let h = area.h() as usize;
            self.height.store(h, Ordering::Relaxed);
            self.width.store(area.w() as usize, Ordering::Relaxed);
            let mut axis = self.note_axis.write().unwrap();
            if let Some(point) = axis.point {
                if point.saturating_sub(axis.start) > (h * 2).saturating_sub(1) {
                    axis.start += 2;
                }
            }
            Ok(if to.area().h() >= 2 {
                let area = to.area();
                to.buffer_update(area, &move |cell, x, y|{
                    cell.set_bg(notes_bg_null);
                    let src_x = (x as usize + time_start) * time_scale;
                    let src_y = y as usize + note_start / 2;
                    if src_x < buffer.width && src_y < buffer.height - 1 {
                        buffer.get(src_x, buffer.height - src_y - 2).map(|src|{
                            cell.set_symbol(src.symbol());
                            cell.set_fg(src.fg);
                            cell.set_bg(src.bg);
                        });
                    }
                });
            })
        }).fill_x();
        let cursor = CustomWidget::new(|to|Ok(Some(to)), move|to: &mut TuiOutput|{
            Ok(if *focused && *entered {
                let area = to.area();
                if let (Some(time), Some(note)) = (time_point, note_point) {
                    let x1 = area.x() + (time / time_scale) as u16;
                    let x2 = x1 + (self.note_len / time_scale) as u16;
                    let y = area.y() + note.saturating_sub(note_start) as u16 / 2;
                    let c = if note % 2 == 0 { "▀" } else { "▄" };
                    for x in x1..x2 {
                        to.blit(&c, x, y, Some(Style::default().fg(Color::Rgb(0,255,0))));
                    }
                }
            })
        });
        let playhead_inactive = Style::default().fg(Color::Rgb(255,255,255)).bg(Color::Rgb(40,50,30));
        let playhead_active   = playhead_inactive.clone().yellow().bold().not_dim();
        let playhead = CustomWidget::new(
            |to:[u16;2]|Ok(Some(to.clip_h(1))),
            move|to: &mut TuiOutput|{
                if let Some(_) = phrase {
                    let now = self.now.get() as usize; // TODO FIXME: self.now % phrase.read().unwrap().length;
                    let time_clamp = time_clamp
                        .expect("time_axis of sequencer expected to be clamped");
                    for x in 0..(time_clamp/time_scale).saturating_sub(time_start) {
                        let this_step = time_start + (x + 0) * time_scale;
                        let next_step = time_start + (x + 1) * time_scale;
                        let x         = to.area().x() + x as u16;
                        let active    = this_step <= now && now < next_step;
                        let character = if active { "|" } else { "·" };
                        let style     = if active { playhead_active } else { playhead_inactive };
                        to.blit(&character, x, to.area.y(), Some(style));
                    }
                }
                Ok(())
            }
        ).push_x(6).align_sw();
        let border_color    = if *focused{Color::Rgb(100, 110, 40)}else{Color::Rgb(70,   80,  50)};
        let title_color     = if *focused{Color::Rgb(150, 160, 90)}else{Color::Rgb(120, 130, 100)};
        let border          = Lozenge(Style::default().bg(Color::Rgb(40, 50, 30)).fg(border_color));
        let note_area       = lay!(notes, cursor).fill_x();
        let piano_roll      = row!(keys, note_area).fill_x();
        let content         = piano_roll.bg(Color::Rgb(40, 50, 30)).border(border);
        let content         = lay!(content, playhead);
        let mut upper_left  = format!("[{}] Sequencer", if *entered {"■"} else {" "});
        if let Some(phrase) = phrase {
            upper_left = format!("{upper_left}: {}", phrase.read().unwrap().name);
        }
        let mut lower_right = format!(
            "┤{}x{}├",
            self.width.load(Ordering::Relaxed),
            self.height.load(Ordering::Relaxed),
        );
        lower_right = format!("┤Zoom: {}├─{lower_right}", pulses_to_name(time_scale));
        //lower_right = format!("Zoom: {} (+{}:{}*{}|{})",
            //pulses_to_name(time_scale),
            //time_start, time_point.unwrap_or(0),
            //time_scale, time_clamp.unwrap_or(0),
        //);
        if *focused && *entered {
            lower_right = format!("┤Note: {} {}├─{lower_right}",
                self.note_axis.read().unwrap().point.unwrap(),
                pulses_to_name(*note_len));
            //lower_right = format!("Note: {} (+{}:{}|{})  {upper_right}",
                //pulses_to_name(*note_len),
                //note_start,
                //note_point.unwrap_or(0),
                //note_clamp.unwrap_or(0),
            //);
        }
        let upper_right = if let Some(phrase) = phrase {
            format!("┤Length: {}├", phrase.read().unwrap().length)
        } else {
            String::new()
        };
        lay!(
            content,
            TuiStyle::fg(upper_left.to_string(),  title_color).push_x(1).align_nw().fill_xy(),
            TuiStyle::fg(upper_right.to_string(), title_color).pull_x(1).align_ne().fill_xy(),
            TuiStyle::fg(lower_right.to_string(), title_color).pull_x(1).align_se().fill_xy(),
        )
    }
}

impl<E: Engine> PhraseEditor<E> {
    pub fn new () -> Self {
        Self {
            _engine:   Default::default(),
            phrase:    None,
            note_len:  24,
            notes_in:  Arc::new(RwLock::new([false;128])),
            notes_out: Arc::new(RwLock::new([false;128])),
            keys:      keys_vert(),
            buffer:    Default::default(),
            focused:   false,
            entered:   false,
            mode:      false,
            now:       Arc::new(0.into()),
            width:     0.into(),
            height:    0.into(),
            note_axis: RwLock::new(FixedAxis  {
                start: 12,
                point: Some(36),
                clamp: Some(127)
            }),
            time_axis: RwLock::new(ScaledAxis {
                start: 00,
                point: Some(00),
                clamp: Some(000),
                scale: 24
            }),
        }
    }

    pub fn time_cursor_advance (&self) {
        let point   = self.time_axis.read().unwrap().point;
        let length  = self.phrase.as_ref().map(|p|p.read().unwrap().length).unwrap_or(1);
        let forward = |time|(time + self.note_len) % length;
        self.time_axis.write().unwrap().point = point.map(forward);
    }

    pub fn put (&mut self) {
        if let (Some(phrase), Some(time), Some(note)) = (
            &self.phrase,
            self.time_axis.read().unwrap().point,
            self.note_axis.read().unwrap().point,
        ) {
            let mut phrase = phrase.write().unwrap();
            let key: u7 = u7::from((127 - note) as u8);
            let vel: u7 = 100.into();
            let start = time;
            let end   = (start + self.note_len) % phrase.length;
            phrase.notes[time].push(MidiMessage::NoteOn { key, vel });
            phrase.notes[end].push(MidiMessage::NoteOff { key, vel });
            self.buffer = Self::redraw(&phrase);
        }
    }
    /// Select which pattern to display. This pre-renders it to the buffer at full resolution.
    pub fn show (&mut self, phrase: Option<&Arc<RwLock<Phrase>>>) {
        if let Some(phrase) = phrase {
            self.phrase = Some(phrase.clone());
            self.time_axis.write().unwrap().clamp = Some(phrase.read().unwrap().length);
            self.buffer = Self::redraw(&*phrase.read().unwrap());
        } else {
            self.phrase = None;
            self.time_axis.write().unwrap().clamp = Some(0);
            self.buffer = Default::default();
        }
    }
    fn redraw (phrase: &Phrase) -> BigBuffer {
        let mut buf = BigBuffer::new(usize::MAX.min(phrase.length), 65);
        Self::fill_seq_bg(&mut buf, phrase.length, phrase.ppq);
        Self::fill_seq_fg(&mut buf, &phrase);
        buf
    }
    fn fill_seq_bg (buf: &mut BigBuffer, length: usize, ppq: usize) {
        for x in 0..buf.width {
            // Only fill as far as phrase length
            if x as usize >= length { break }
            // Fill each row with background characters
            for y in 0 .. buf.height {
                buf.get_mut(x, y).map(|cell|{
                    cell.set_char(if ppq == 0 {
                        '·'
                    } else if x % (4 * ppq) == 0 {
                        '│'
                    } else if x % ppq == 0 {
                        '╎'
                    } else {
                        '·'
                    });
                    cell.set_fg(Color::Rgb(48, 64, 56));
                    cell.modifier = Modifier::DIM;
                });
            }
        }
    }
    fn fill_seq_fg (buf: &mut BigBuffer, phrase: &Phrase) {
        let mut notes_on = [false;128];
        for x in 0..buf.width {
            if x as usize >= phrase.length {
                break
            }
            if let Some(notes) = phrase.notes.get(x as usize) {
                if phrase.percussive {
                    for note in notes {
                        match note {
                            MidiMessage::NoteOn { key, .. } =>
                                notes_on[key.as_int() as usize] = true,
                            _ => {}
                        }
                    }
                } else {
                    for note in notes {
                        match note {
                            MidiMessage::NoteOn { key, .. } =>
                                notes_on[key.as_int() as usize] = true,
                            MidiMessage::NoteOff { key, .. } =>
                                notes_on[key.as_int() as usize] = false,
                            _ => {}
                        }
                    }
                }
                for y in 0..buf.height {
                    if y >= 64 {
                        break
                    }
                    if let Some(block) = half_block(
                        notes_on[y as usize * 2],
                        notes_on[y as usize * 2 + 1],
                    ) {
                        buf.get_mut(x, y).map(|cell|{
                            cell.set_char(block);
                            cell.set_fg(Color::White);
                        });
                    }
                }
                if phrase.percussive {
                    notes_on.fill(false);
                }
            }
        }
    }
}

/// Colors of piano keys
const KEY_COLORS: [(Color, Color);6] = [
    (Color::Rgb(255, 255, 255), Color::Rgb(255, 255, 255)),
    (Color::Rgb(0, 0, 0),       Color::Rgb(255, 255, 255)),
    (Color::Rgb(0, 0, 0),       Color::Rgb(255, 255, 255)),
    (Color::Rgb(0, 0, 0),       Color::Rgb(255, 255, 255)),
    (Color::Rgb(255, 255, 255), Color::Rgb(0, 0, 0)),
    (Color::Rgb(255, 255, 255), Color::Rgb(0, 0, 0)),
];

pub(crate) fn keys_vert () -> Buffer {
    let area = [0, 0, 5, 64];
    let mut buffer = Buffer::empty(Rect {
        x: area.x(), y: area.y(), width: area.w(), height: area.h()
    });
    buffer_update(&mut buffer, area, &|cell, x, y| {
        let y = 63 - y;
        match x {
            0 => {
                cell.set_char('▀');
                let (fg, bg) = KEY_COLORS[((6 - y % 6) % 6) as usize];
                cell.set_fg(fg);
                cell.set_bg(bg);
            },
            1 => {
                cell.set_char('▀');
                cell.set_fg(Color::White);
                cell.set_bg(Color::White);
            },
            2 => if y % 6 == 0 {
                cell.set_char('C');
            },
            3 => if y % 6 == 0 {
                cell.set_symbol(NTH_OCTAVE[(y / 6) as usize]);
            },
            _ => {}
        }
    });
    buffer
}

const NTH_OCTAVE: [&'static str; 11] = [
    "-2", "-1", "0", "1", "2", "3", "4", "5", "6", "7", "8",
];