import lcm from './lcm'

import WeakMap from 'weak-map'

const propMap = new WeakMap()

const BITS_PER_BYTE = 8

export default class CharSet {

constructor(chars) {

if (!(typeof chars === 'string' || chars instanceof String)) {

throw new Error('Invalid chars: Must be string')

}

const length = chars.length

if (![2,4,8,16,32,64].includes(length)) {

throw new Error('Invalid char count: must be one of 2,4,8,16,32,64')

}

const bitsPerChar = Math.floor(Math.log2(length))

// Ensure no repeated characters

for (let i = 0; i < length; i++) {

let c = chars.charAt(i)

for (let j = i+1; j < length; j++) {

if (c === chars.charAt(j)) {

throw new Error('Characters not unique')

}

}

}

const privProps = {

chars,

bitsPerChar,

length,

ndxFn: _ndxFn(bitsPerChar),

charsPerChunk: lcm(bitsPerChar, BITS_PER_BYTE) / bitsPerChar

}

propMap.set(this, privProps)

}

getChars() {

return propMap.get(this).chars

}

getBitsPerChar() {

return propMap.get(this).bitsPerChar

}

getNdxFn() {

return propMap.get(this).ndxFn

}

getCharsPerChunk() {

return propMap.get(this).charsPerChunk

}

length() {

return propMap.get(this).length

}

getNdxFn() {

return propMap.get(this).ndxFn

}

bytesNeeded(entropyBits) {

const count = Math.ceil(entropyBits / this.bitsPerChar())

return Math.ceil(count * this.bitsPerChar() / BITS_PER_BYTE)

}

// Aliases

chars() { return this.getChars() }

ndxFn() { return this.getNdxFn() }

bitsPerChar() { return this.getBitsPerChar() }

}

const _ndxFn = (bitsPerChar) => {

// If BITS_PER_BYTEs is a multiple of bitsPerChar, we can slice off an integer number

// of chars per byte.

if (lcm(bitsPerChar, BITS_PER_BYTE) === BITS_PER_BYTE) {

return function(chunk, slice, bytes) {

let lShift = bitsPerChar

let rShift = BITS_PER_BYTE - bitsPerChar

return ((bytes[chunk]<<(lShift*slice))&0xff)>>rShift

}

}

// Otherwise, while slicing off bits per char, we will possibly straddle a couple

// of bytes, so a bit more work is involved

else {

let slicesPerChunk = lcm(bitsPerChar, BITS_PER_BYTE) / BITS_PER_BYTE

return function(chunk, slice, bytes) {

let bNum = chunk * slicesPerChunk

let offset = (slice*bitsPerChar)/BITS_PER_BYTE

let lOffset = Math.floor(offset)

let rOffset = Math.ceil(offset)

let rShift = BITS_PER_BYTE - bitsPerChar

let lShift = (slice*bitsPerChar) % BITS_PER_BYTE

let ndx = ((bytes[bNum+lOffset]<<lShift)&0xff)>>rShift

let rShiftIt = ((rOffset+1)*BITS_PER_BYTE - (slice+1)*bitsPerChar) % BITS_PER_BYTE

if (rShift < rShiftIt) {

ndx += bytes[bNum+rOffset]>>rShiftIt

}

return ndx

}

}

}

export let charSet64 = new CharSet('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_')

export let charSet32 = new CharSet('2346789bdfghjmnpqrtBDFGHJLMNPQRT')

export let charSet16 = new CharSet('0123456789abcdef')

export let charSet8 = new CharSet('01234567')

export let charSet4 = new CharSet('ATCG')

export let charSet2 = new CharSet('01')