import { Base64BitflagSet } from '@module'
import { decodeByte, encodeByte } from '../src/base64'

test('Create from an index', () => {
    const flags = new Base64BitflagSet()

    const flag2 = flags.flag(2)
    expect(flag2.addTo('')).toEqual('C')

    expect(() => flags.flag(0)).toThrow(RangeError)
    expect(() => flags.flag(-2)).toThrow(RangeError)
})

test('Union of two base-64 strings', () => {
    const flags = new Base64BitflagSet()

    expect(flags.union('', '')).toEqual('A')
    expect(flags.union('A', 'A')).toEqual('A')
    expect(flags.union('B', 'A')).toEqual('B')
    expect(flags.union('A', 'C')).toEqual('C')
    expect(flags.union('B', 'C')).toEqual('D')
    expect(flags.union('D', 'G')).toEqual('H')
})

test('Difference of two base-64 strings', () => {
    const flags = new Base64BitflagSet()

    expect(flags.difference('', '')).toEqual('A')
    expect(flags.difference('A', 'A')).toEqual('A')
    expect(flags.difference('B', 'A')).toEqual('B')
    expect(flags.difference('D', 'G')).toEqual('B')
    expect(flags.difference('G', 'D')).toEqual('E')
    expect(flags.difference('IB', 'R')).toEqual('IB')
})

test('Intersection of two base-64 strings', () => {
    const flags = new Base64BitflagSet()

    expect(flags.intersection('', '')).toEqual('A')
    expect(flags.intersection('A', 'A')).toEqual('A')
    expect(flags.intersection('B', 'A')).toEqual('A')
    expect(flags.intersection('B', 'C')).toEqual('A')
    expect(flags.intersection('B', 'D')).toEqual('B')
    expect(flags.intersection('L', 'F')).toEqual('B')
    expect(flags.intersection('L', 'H')).toEqual('D')
})

test('Iterate over a base-64 string', () => {
    const flags = new Base64BitflagSet()

    expect([...flags.iterate('A')]).toEqual([])
    expect([...flags.iterate('B')]).toEqual([1])
    expect([...flags.iterate('C')]).toEqual([2])
    expect([...flags.iterate('D')]).toEqual([1, 2])
    expect([...flags.iterate('L')]).toEqual([1, 2, 4])
    expect([...flags.iterate('kB')]).toEqual([3, 6, 7])
})

test('Normalise to minimum', () => {
    const flags = new Base64BitflagSet()
    const flag1 = flags.flag(1)
    const flag2 = flags.flag(2, flag1)
    const flag3 = flags.flag(3, flag1)
    const flag4 = flags.flag(4, flag3)

    expect(flags.minimum('A')).toEqual('A')
    expect(flags.minimum('B')).toEqual('B')
    expect(flags.minimum('C')).toEqual('A')
    expect(flags.minimum('D')).toEqual('D')
    expect(flags.minimum('L')).toEqual('D')
    expect(flags.minimum('N')).toEqual('N')
    expect(flags.minimum('R')).toEqual('B')
})

test('Normalise to maximum', () => {
    const flags = new Base64BitflagSet()
    const flag1 = flags.flag(1)
    const flag2 = flags.flag(2, flag1)
    const flag3 = flags.flag(3, flag1)
    const flag4 = flags.flag(4, flag3)

    expect(flags.maximum('A')).toEqual('A')
    expect(flags.maximum('B')).toEqual('B')
    expect(flags.maximum('C')).toEqual('D')
    expect(flags.maximum('D')).toEqual('D')
    expect(flags.maximum('L')).toEqual('P')
    expect(flags.maximum('N')).toEqual('N')
    expect(flags.maximum('R')).toEqual('B')
})

test('Add to base64 string', () => {
    const flags = new Base64BitflagSet()
    const flag2 = flags.flag(2)
    const flag3 = flags.flag(3)
    const flags2And3 = flags.flag(flag2, flag3)

    expect(flag2.addTo('B')).toEqual('D')
    expect(flag3.addTo('B')).toEqual('F')
    expect(flags2And3.addTo('B')).toEqual('H')
})

test('Remove from base64 string', () => {
    const flags = new Base64BitflagSet()
    const flag1 = flags.flag(1)
    const flag2 = flags.flag(2)
    const flag3 = flags.flag(3, flag1)

    expect(flag1.removeFrom('H')).toEqual('C')
    expect(flag2.removeFrom('H')).toEqual('F')
    expect(flag3.removeFrom('H')).toEqual('D')
})

test('Is in base64 string', () => {
    const flags = new Base64BitflagSet()
    const flag1 = flags.flag(1)
    const flag2 = flags.flag(2)
    const flag3 = flags.flag(3, flag1)

    expect(flag1.isIn('B')).toBe(true)
    expect(flag2.isIn('D')).toBe(true)
    expect(flag3.isIn('E')).toBe(false)
    expect(flag3.isIn('F')).toBe(true)
})

test('Is abstract', () => {
    const flags = new Base64BitflagSet()
    const flag1 = flags.flag(1)
    const flag2 = flags.flag(2)
    const flags1And2 = flags.flag(flag1, flag2)
    const flag3 = flags.flag(3, flags1And2)

    expect(flag1.isAbstract).toBe(false)
    expect(flag2.isAbstract).toBe(false)
    expect(flags1And2.isAbstract).toBe(true)
    expect(flag3.isAbstract).toBe(false)
})

test('encode a base-64 byte', () => {
    expect(encodeByte(0)).toEqual('A')
    expect(encodeByte(1)).toEqual('B')
    expect(encodeByte(2)).toEqual('C')
    expect(encodeByte(3)).toEqual('D')
    expect(encodeByte(4)).toEqual('E')
    expect(encodeByte(5)).toEqual('F')
    expect(encodeByte(6)).toEqual('G')
    expect(encodeByte(7)).toEqual('H')
    expect(encodeByte(8)).toEqual('I')
    expect(encodeByte(9)).toEqual('J')
    expect(encodeByte(10)).toEqual('K')
    expect(encodeByte(11)).toEqual('L')
    expect(encodeByte(12)).toEqual('M')
    expect(encodeByte(13)).toEqual('N')
    expect(encodeByte(14)).toEqual('O')
    expect(encodeByte(15)).toEqual('P')
    expect(encodeByte(16)).toEqual('Q')
    expect(encodeByte(17)).toEqual('R')
    expect(encodeByte(18)).toEqual('S')
    expect(encodeByte(19)).toEqual('T')
    expect(encodeByte(20)).toEqual('U')
    expect(encodeByte(21)).toEqual('V')
    expect(encodeByte(22)).toEqual('W')
    expect(encodeByte(23)).toEqual('X')
    expect(encodeByte(24)).toEqual('Y')
    expect(encodeByte(25)).toEqual('Z')
    expect(encodeByte(26)).toEqual('a')
    expect(encodeByte(27)).toEqual('b')
    expect(encodeByte(28)).toEqual('c')
    expect(encodeByte(29)).toEqual('d')
    expect(encodeByte(30)).toEqual('e')
    expect(encodeByte(31)).toEqual('f')
    expect(encodeByte(32)).toEqual('g')
    expect(encodeByte(33)).toEqual('h')
    expect(encodeByte(34)).toEqual('i')
    expect(encodeByte(35)).toEqual('j')
    expect(encodeByte(36)).toEqual('k')
    expect(encodeByte(37)).toEqual('l')
    expect(encodeByte(38)).toEqual('m')
    expect(encodeByte(39)).toEqual('n')
    expect(encodeByte(40)).toEqual('o')
    expect(encodeByte(41)).toEqual('p')
    expect(encodeByte(42)).toEqual('q')
    expect(encodeByte(43)).toEqual('r')
    expect(encodeByte(44)).toEqual('s')
    expect(encodeByte(45)).toEqual('t')
    expect(encodeByte(46)).toEqual('u')
    expect(encodeByte(47)).toEqual('v')
    expect(encodeByte(48)).toEqual('w')
    expect(encodeByte(49)).toEqual('x')
    expect(encodeByte(50)).toEqual('y')
    expect(encodeByte(51)).toEqual('z')
    expect(encodeByte(52)).toEqual('0')
    expect(encodeByte(53)).toEqual('1')
    expect(encodeByte(54)).toEqual('2')
    expect(encodeByte(55)).toEqual('3')
    expect(encodeByte(56)).toEqual('4')
    expect(encodeByte(57)).toEqual('5')
    expect(encodeByte(58)).toEqual('6')
    expect(encodeByte(59)).toEqual('7')
    expect(encodeByte(60)).toEqual('8')
    expect(encodeByte(61)).toEqual('9')
    expect(encodeByte(62)).toEqual('-')
    expect(encodeByte(63)).toEqual('_')
})

test('encode a base-64 byte', () => {
    expect(decodeByte('A')).toEqual(0)
    expect(decodeByte('B')).toEqual(1)
    expect(decodeByte('C')).toEqual(2)
    expect(decodeByte('D')).toEqual(3)
    expect(decodeByte('E')).toEqual(4)
    expect(decodeByte('F')).toEqual(5)
    expect(decodeByte('G')).toEqual(6)
    expect(decodeByte('H')).toEqual(7)
    expect(decodeByte('I')).toEqual(8)
    expect(decodeByte('J')).toEqual(9)
    expect(decodeByte('K')).toEqual(10)
    expect(decodeByte('L')).toEqual(11)
    expect(decodeByte('M')).toEqual(12)
    expect(decodeByte('N')).toEqual(13)
    expect(decodeByte('O')).toEqual(14)
    expect(decodeByte('P')).toEqual(15)
    expect(decodeByte('Q')).toEqual(16)
    expect(decodeByte('R')).toEqual(17)
    expect(decodeByte('S')).toEqual(18)
    expect(decodeByte('T')).toEqual(19)
    expect(decodeByte('U')).toEqual(20)
    expect(decodeByte('V')).toEqual(21)
    expect(decodeByte('W')).toEqual(22)
    expect(decodeByte('X')).toEqual(23)
    expect(decodeByte('Y')).toEqual(24)
    expect(decodeByte('Z')).toEqual(25)
    expect(decodeByte('a')).toEqual(26)
    expect(decodeByte('b')).toEqual(27)
    expect(decodeByte('c')).toEqual(28)
    expect(decodeByte('d')).toEqual(29)
    expect(decodeByte('e')).toEqual(30)
    expect(decodeByte('f')).toEqual(31)
    expect(decodeByte('g')).toEqual(32)
    expect(decodeByte('h')).toEqual(33)
    expect(decodeByte('i')).toEqual(34)
    expect(decodeByte('j')).toEqual(35)
    expect(decodeByte('k')).toEqual(36)
    expect(decodeByte('l')).toEqual(37)
    expect(decodeByte('m')).toEqual(38)
    expect(decodeByte('n')).toEqual(39)
    expect(decodeByte('o')).toEqual(40)
    expect(decodeByte('p')).toEqual(41)
    expect(decodeByte('q')).toEqual(42)
    expect(decodeByte('r')).toEqual(43)
    expect(decodeByte('s')).toEqual(44)
    expect(decodeByte('t')).toEqual(45)
    expect(decodeByte('u')).toEqual(46)
    expect(decodeByte('v')).toEqual(47)
    expect(decodeByte('w')).toEqual(48)
    expect(decodeByte('x')).toEqual(49)
    expect(decodeByte('y')).toEqual(50)
    expect(decodeByte('z')).toEqual(51)
    expect(decodeByte('0')).toEqual(52)
    expect(decodeByte('1')).toEqual(53)
    expect(decodeByte('2')).toEqual(54)
    expect(decodeByte('3')).toEqual(55)
    expect(decodeByte('4')).toEqual(56)
    expect(decodeByte('5')).toEqual(57)
    expect(decodeByte('6')).toEqual(58)
    expect(decodeByte('7')).toEqual(59)
    expect(decodeByte('8')).toEqual(60)
    expect(decodeByte('9')).toEqual(61)
    expect(decodeByte('-')).toEqual(62)
    expect(decodeByte('_')).toEqual(63)
})