// metricsFromCairo fills in the font metrics with the font metrics as
// measured on a cairo Context.
func (f *Font) metricsFromCairo(cr *cairo.Context) {
	ext := cairo.FontExtents{}
	cr.FontExtents(&ext)
	f.cw = int(ext.MaxXAdvance)
	f.ch = int(ext.Height)
	f.descent = int(ext.Descent)
}

func (f *Font) Use(cr *cairo.Context, bold bool) {
	weight := cairo.FontWeightNormal
	if bold {
		weight = cairo.FontWeightBold
	}
	cr.SelectFontFace(f.Name, cairo.FontSlantNormal, weight)
	cr.SetFontSize(float64(f.Size))
	if f.cw == 0 {
		f.metricsFromCairo(cr)
	}
}

func drawText(cr *cairo.Context, mf *Font, x, y int, fg, bg *Color, line string) {
	if bg != nil {
		setColor(cr, bg)
		cr.Rectangle(float64(x), float64(y),
			float64(len(line)*mf.cw), float64(mf.ch))
		cr.Fill()
	}

	cr.MoveTo(float64(x), float64(y+mf.ch-mf.descent))
	setColor(cr, fg)
	cr.ShowText(line)
}

func (l *LogView) Draw(cr *cairo.Context) {
	cr.Translate(0, float64(-l.scrollOffset))
	y := 0
	for _, e := range l.Entries {
		h := e.prompt.Height()
		if y+h >= l.scrollOffset {
			e.prompt.Draw(cr)
		}
		y += h
		cr.Translate(0, float64(h))
		if e.term != nil {
			h = e.term.Height()
			if y+h >= l.scrollOffset {
				e.term.Draw(cr)
			}
			y += h
			cr.Translate(0, float64(h))
		}
	}
	if y > l.height {
		scrollOffset := y - l.height
		if l.scrollOffset != scrollOffset {
			if l.scrollAnim != nil && l.scrollAnim.Done {
				l.scrollAnim = nil
			}
			if l.scrollAnim == nil {
				l.scrollAnim = ui.NewLerp(&l.scrollOffset, scrollOffset, 40*time.Millisecond)
				l.GetWindow().win.AddAnimation(l.scrollAnim)
			} else {
				// TODO adjust existing anim
			}
		}
	}
}

func (t *TermView) Draw(cr *cairo.Context) {
	t.mf.Use(cr, false)

	t.termMu.Lock()
	defer t.termMu.Unlock()

	offset := t.term.Top * t.mf.ch
	offset = 0
	if offset > 0 {
		cr.Save()
		defer cr.Restore()
		cr.Translate(0, float64(-offset))
	}

	firstLine := offset / t.mf.ch
	if firstLine < 0 {
		firstLine = 0
	}
	lastLine := t.term.Top + t.term.Height
	if lastLine > len(t.term.Lines) {
		lastLine = len(t.term.Lines)
	}

	for row := firstLine; row < lastLine; row++ {
		drawTerminalLine(cr, t.mf, row*t.mf.ch, t.term.Lines[row])
	}

	if !t.term.HideCursor {
		ch := rune(0)
		if t.term.Row < len(t.term.Lines) &&
			t.term.Col < len(t.term.Lines[t.term.Row]) {
			ch = t.term.Lines[t.term.Row][t.term.Col].Ch
		}
		drawCursor(cr, t.mf, t.term.Row, t.term.Col, ch)
	}
}

func setColor(cr *cairo.Context, color *Color) {
	cr.SetSourceRGB(float64(color.R)/0xff, float64(color.G)/0xff, float64(color.B)/0xff)
}

func (w *Window) Draw(cr *cairo.Context) {
	cr.SetSourceRGB(1, 1, 1)
	cr.Paint()
	w.View.Draw(cr)
}