use crate::*;

impl Sequencer {

    const H_KEYS_OFFSET: usize = 5;

    pub(crate) fn horizontal_draw (&self, buf: &mut Buffer, mut area: Rect) -> Usually<()> {
        Split::down()
            .add_ref(&SequenceName(&self))
            .add_ref(&SequenceRange)
            .add_ref(&SequenceLoopRange)
            .add_ref(&SequenceNoteRange)
            .render(buf, Rect { x: area.x, y: area.y, width: 10, height: area.height })?;
        area.x = area.x + 10;
        area.width = area.width.saturating_sub(10);
        area.height = area.height.min(66);
        Lozenge(Style::default().fg(Nord::BG2)).draw(buf, area)?;
        area.x = area.x + 1;
        area.width = area.width.saturating_sub(1);
        Layered::new()
            .add_ref(&SequenceKeys(&self))
            .add_ref(&self.phrase.as_ref().map(|phrase|SequenceTimer(&self, phrase.clone())))
            .add_ref(&SequenceNotes(&self))
            .add_ref(&SequenceCursor(&self))
            .add_ref(&SequenceZoom(&self))
            .render(buf, area)?;
        Ok(())
    }

}

const STYLE_LABEL: Option<Style> = Some(Style {
    fg: Some(Color::Reset),
    bg: None,
    underline_color: None,
    add_modifier:    Modifier::empty(),
    sub_modifier:    Modifier::BOLD,
});

const STYLE_VALUE: Option<Style> = Some(Style {
    fg: Some(Color::White),
    bg: None,
    underline_color: None,
    add_modifier:    Modifier::BOLD,
    sub_modifier:    Modifier::DIM,
});

struct SequenceName<'a>(&'a Sequencer);

impl<'a> Render for SequenceName<'a> {
    fn render (&self, buf: &mut Buffer, area: Rect) -> Usually<Rect> {
        let Rect { x, y, .. } = area;
        let frame = Rect { x, y, width: 10, height: 4 };
        Lozenge(Style::default().fg(Nord::BG2)).draw(buf, frame)?;
        "Name:".blit(buf, x + 1, y + 1, STYLE_LABEL)?;
        self.0.name.read().unwrap().blit(buf, x + 1, y + 2, STYLE_VALUE)?;
        Ok(frame)
    }
}

struct SequenceRange;

impl Render for SequenceRange {
    fn render (&self, buf: &mut Buffer, area: Rect) -> Usually<Rect> {
        let Rect { x, y, .. } = area;
        let frame = Rect { x, y, width: 10, height: 6 };
        Lozenge(Style::default().fg(Nord::BG2)).draw(buf, frame)?;
        "Start:  ".blit(buf, x + 1, y + 1, STYLE_LABEL)?;
        "   1.1.1".blit(buf, x + 1, y + 2, STYLE_VALUE)?;
        "End:    ".blit(buf, x + 1, y + 3, STYLE_LABEL)?;
        "   2.1.1".blit(buf, x + 1, y + 4, STYLE_VALUE)?;
        Ok(frame)
    }
}

struct SequenceLoopRange;

impl Render for SequenceLoopRange {
    fn render (&self, buf: &mut Buffer, area: Rect) -> Usually<Rect> {
        let Rect { x, y, .. } = area;
        let range = Rect { x, y, width: 10, height: 7 };
        Lozenge(Style::default().fg(Nord::BG2)).draw(buf, range)?;
        "Loop [ ]".blit(buf, x + 1, y + 1, STYLE_LABEL)?;
        "From:   ".blit(buf, x + 1, y + 2, STYLE_LABEL)?;
        "   1.1.1".blit(buf, x + 1, y + 3, STYLE_VALUE)?;
        "Length: ".blit(buf, x + 1, y + 4, STYLE_LABEL)?;
        "   1.0.0".blit(buf, x + 1, y + 5, STYLE_VALUE)?;
        Ok(range)
    }
}

struct SequenceNoteRange;

impl Render for SequenceNoteRange {
    fn render (&self, buf: &mut Buffer, area: Rect) -> Usually<Rect> {
        let Rect { x, y, .. } = area;
        let range = Rect { x, y, width: 10, height: 9 };
        Lozenge(Style::default().fg(Nord::BG2)).draw(buf, range)?;
        "Notes:  ".blit(buf, x + 1, y + 1, STYLE_LABEL)?;
        "C#0-C#9 ".blit(buf, x + 1, y + 2, STYLE_VALUE)?;
        "[  /2  ]".blit(buf, x + 1, y + 3, STYLE_LABEL)?;
        "[  x2  ]".blit(buf, x + 1, y + 4, STYLE_LABEL)?;
        "[ Rev  ]".blit(buf, x + 1, y + 5, STYLE_LABEL)?;
        "[ Inv  ]".blit(buf, x + 1, y + 6, STYLE_LABEL)?;
        "[ Dup  ]".blit(buf, x + 1, y + 7, STYLE_LABEL)?;
        Ok(area)
    }
}

struct SequenceKeys<'a>(&'a Sequencer);

impl<'a> Render for SequenceKeys<'a> {
    fn render (&self, buf: &mut Buffer, area: Rect) -> Usually<Rect> {
        if area.height < 2 {
            return Ok(area)
        }
        let area = Rect {
            x: area.x,
            y: area.y + 1,
            width: 5,
            height: area.height - 2
        };
        buffer_update(buf, area, &|cell, x, y|{
            let y = y + self.0.note_axis.start as u16;
            if x < self.0.keys.area.width && y < self.0.keys.area.height {
                *cell = self.0.keys.get(x, y).clone()
            }
        });
        Ok(area)
    }
}

struct SequenceNotes<'a>(&'a Sequencer);

impl<'a> Render for SequenceNotes<'a> {
    fn render (&self, buf: &mut Buffer, area: Rect) -> Usually<Rect> {
        if area.height < 2 {
            return Ok(area)
        }
        let area = Rect {
            x:      area.x + Sequencer::H_KEYS_OFFSET as u16,
            y:      area.y + 1,
            width:  area.width - Sequencer::H_KEYS_OFFSET as u16,
            height: area.height - 2
        };
        buffer_update(buf, area, &move |cell, x, y|{
            let src_x = ((x as usize + self.0.time_axis.start) * self.0.time_axis.scale) as usize;
            let src_y = (y as usize + self.0.note_axis.start) as usize;
            if src_x < self.0.buffer.width && src_y < self.0.buffer.height - 1 {
                let src = self.0.buffer.get(src_x, self.0.buffer.height - src_y);
                src.map(|src|{
                    cell.set_symbol(src.symbol());
                    cell.set_fg(src.fg);
                });
            }
        });
        Ok(area)
    }
}

struct SequenceCursor<'a>(&'a Sequencer);

impl<'a> Render for SequenceCursor<'a> {
    fn render (&self, buf: &mut Buffer, area: Rect) -> Usually<Rect> {
        if let (Some(time), Some(note)) = (self.0.time_axis.point, self.0.note_axis.point) {
            let x = area.x + Sequencer::H_KEYS_OFFSET as u16 + time as u16;
            let y = area.y + 1 + note as u16 / 2;
            let c = if note % 2 == 0 { "▀" } else { "▄" };
            c.blit(buf, x, y, self.0.style_focus())
        } else {
            Ok(Rect::default())
        }
    }
}

struct SequenceZoom<'a>(&'a Sequencer);

impl<'a> Render for SequenceZoom<'a> {
    fn render (&self, buf: &mut Buffer, area: Rect) -> Usually<Rect> {
        let quant = ppq_to_name(self.0.time_axis.scale);
        let quant_x = area.x + area.width - 1 - quant.len() as u16;
        let quant_y = area.y + area.height - 2;
        quant.blit(buf, quant_x, quant_y, self.0.style_focus())
    }
}

struct SequenceTimer<'a>(&'a Sequencer, Arc<RwLock<Phrase>>);

impl<'a> Render for SequenceTimer<'a> {
    fn render (&self, buf: &mut Buffer, area: Rect) -> Usually<Rect> {
        let phrase = self.1.read().unwrap();
        let (time0, time_z, now) = (
            self.0.time_axis.start, self.0.time_axis.scale, self.0.now % phrase.length
        );
        let Rect { x, width, .. } = area;
        let x2 = x as usize + Sequencer::H_KEYS_OFFSET;
        let x3 = x as usize + width as usize;
        for x in x2..x3 {
            let step = (time0 + x2) * time_z;
            let next_step = (time0 + x2 + 1) * time_z;
            let style = Sequencer::style_timer_step(now, step as usize, next_step as usize);
            "-".blit(buf, x as u16, area.y, Some(style))?;
        }
        return Ok(Rect { x: area.x, y: area.y, width: area.width, height: 1 })
    }
}