/** @deprecated Buggy legacy library, don't use it. Use utils/urlJSON instead. */

const CODES = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-.";
// Not used symbols _!~*'()
const NUM_CODES = "0123456789.e+-";
const NUM_CODES_SIZE = Math.ceil(Math.log(NUM_CODES.length) / Math.log(2));

const MAX_INT_SIZE = Math.log(Number.MAX_SAFE_INTEGER) / Math.log(2);

function NumberToBytes(val) {
  return new Uint8Array(new Float64Array([val]).buffer, 0, 8);
}
function NumberFromBytes(val) {
  return new Float64Array(new Uint8Array(val).buffer, 0, 1)[0];
}

function PackJSONBuffer(domain = CODES) {
  this.domain = domain;
  this.bufferCellSize = Math.floor(Math.log(domain.length) / Math.log(2));
  this.clear();
}
Object.defineProperty(PackJSONBuffer.prototype, "lastCell", {
  get() {
    return this.buffer[this.buffer.length - 1];
  },
  set(val) {
    this.buffer[this.buffer.length - 1] = val;
  },
});
PackJSONBuffer.prototype.MAX_INT_CHUNK_SIZE = 30;
PackJSONBuffer.prototype.pushChunk = function (size, val) {
  if (this.readonly) throw Error("Cannot push the chunk. The value is readonly");
  while (size > 0) {
    if (this.avaliableBufferCellSize === 0) {
      this.buffer.push(0);
      this.avaliableBufferCellSize = this.bufferCellSize;
    }
    if (this.avaliableBufferCellSize >= size) {
      this.lastCell |= ((1 << this.bufferCellSize) - 1) & (val << (this.avaliableBufferCellSize -= size));
      size = 0;
    } else {
      this.lastCell |= ((1 << this.bufferCellSize) - 1) & (val >> (size -= this.avaliableBufferCellSize));
      this.avaliableBufferCellSize = 0;
    }
  }
};
PackJSONBuffer.prototype.readChunk = function (size) {
  if (size > this.MAX_INT_CHUNK_SIZE)
    throw Error(`Unsupported size of a chunk. Couldn't be greater than ${this.MAX_INT_CHUNK_SIZE}`);
  let chunk = 0;
  let cellIdx;
  let cellPos;
  let cellValueSize;
  let cellValue;

  while (size > 0) {
    cellPos = this.pos % this.bufferCellSize;
    cellIdx = (this.pos - cellPos) / this.bufferCellSize;
    cellValueSize = this.bufferCellSize - cellPos;
    cellValue = this.buffer[cellIdx] & ((1 << cellValueSize) - 1);
    chunk = (chunk << Math.min(cellValueSize, size)) | (cellValue >> Math.max(cellValueSize - size, 0));
    this.pos += Math.min(cellValueSize, size);
    size -= cellValueSize;
  }
  return chunk;
};
PackJSONBuffer.prototype.seek = function (pos) {
  this.pos = pos;
};
PackJSONBuffer.prototype.readBytes = function (length) {
  return new Uint8Array(length).map(() => this.readChunk(8));
};
PackJSONBuffer.prototype.clear = function () {
  this.buffer = [];
  this.avaliableBufferCellSize = 0;
  this.readonly = false;
  this.pos = 0;
};
PackJSONBuffer.prototype.toString = function () {
  return this.buffer.map((domainIdx) => this.domain[domainIdx]).join("");
};
PackJSONBuffer.prototype.fromString = function (string) {
  this.buffer = string.split("").map((char) => this.domain.indexOf(char));
  this.readonly = true;
  this.pos = 0;
};
PackJSONBuffer.fromString = (string, domain) => new PackJSONBuffer(domain).fromString(string);

/*
body:= [...value]
value :=
  0 spec [0:stop]|[1:true]|[2:false][3:null]
  1 number [0:float]|[1:int]|[2:string]
? 2 string [type][[0:[...[char]|[[.][string_code]]]|[1:...[string_code]]|[2:...[[0:isChar][char]|[1:isCode][string_code]]]]
  3 array [...[value]][0:stop]
  4 object [...[[value:key][value:value]]][0:stop]
  5 definitions
  6 const [value]

definitions:=
   1 dictionary [...bodyValues] (getting by idx)
 */

const CODE_SIZE = 3;

const SPEC_CODE = 0;
const SPEC_LITERALS = [undefined, true, false, null];
const SPEC_SIZE = (SPEC_LITERALS.length - 1).toString(2).length;

const NUMBER_CODE = 1;
const NUMBER_TYPE_SIZE = 2;
const NUMBER_FLOAT_TYPE = 0;
const NUMBER_INTEGER_TYPE = 1;
const NUMBER_STRING_TYPE = 2;

const STRING_CODE = 2;
const STRING_LEN_BLOCK_SIZE = 4;
const STRING_TYPE_SIZE = 3; // with a future potential
const INFREQUENT_CODES_STRING_TYPE = 0;
const ONLY_CODES_STRING_TYPE = 1;
const MARKED_CHARS_STRING_TYPE = 2;

const ARRAY_CODE = 3;

const OBJECT_CODE = 4;

const DEFINITION_CODE = 5;
const DEFINITION_TYPE_SIZE = 2;
const DICT_DEFINITION_TYPE = 1;

const CONST_CODE = 6;

const PackJSON = function (domain) {
  this.buffer = new PackJSONBuffer(domain);
};

PackJSON.prototype.stringify = function (json) {
  this.buffer.clear();
  this.makeDictionaries(json);
  this.encode(json);
  return this.buffer.toString();
};
PackJSON.prototype.parse = function (string) {
  this.buffer.fromString(string);
  this.definitions = [];
  return this.decode();
};
PackJSON.prototype.makeDictionaries = function (json) {
  this.sharedValuesCount = 0;
  this.sharedNumbersDict = {};
  this.sharedStringsDict = {};
  this.tmpSharedValuesSet = new Set();
  this.collectObjectWords(json);
  this.encodeDefinitions();
};
PackJSON.prototype.collectObjectWords = function (value) {
  switch (typeof value) {
    case "number": {
      if (this.tmpSharedValuesSet.has(value) && this.sharedStringsDict[value] === undefined) {
        this.sharedNumbersDict[value] = this.sharedValuesCount++;
      }
      this.tmpSharedValuesSet.add(value);
      break;
    }
    case "string": {
      if (this.tmpSharedValuesSet.has(value) && this.sharedStringsDict[value] === undefined) {
        this.sharedStringsDict[value] = this.sharedValuesCount++;
      }
      this.tmpSharedValuesSet.add(value);
      break;
    }
    case "object": {
      if (value === null) return;
      if (Array.isArray(value)) {
        value.forEach((v) => this.collectObjectWords(v));
      } else {
        for (const [key, val] of Object.entries(value)) {
          this.collectObjectWords(key);
          this.collectObjectWords(val);
        }
      }
      break;
    }
  }
};
PackJSON.prototype.encode = function (value) {
  const type = typeof value;

  switch (type) {
    case "boolean": {
      this.encodeSpec(value);
      break;
    }
    case "number": {
      this.encodeNumber(value);
      break;
    }
    case "string": {
      this.encodeString(value);
      break;
    }
    case "object": {
      if (value === null) {
        this.encodeSpec(value);
      } else if (Array.isArray(value)) {
        this.encodeArray(value);
      } else {
        this.encodeObject(value);
      }
      break;
    }
  }
};
PackJSON.prototype.decode = function () {
  const code = this.buffer.readChunk(CODE_SIZE);

  switch (code) {
    case SPEC_CODE: {
      return this.decodeSpec();
    }
    case NUMBER_CODE: {
      return this.decodeNumber();
    }
    case STRING_CODE: {
      return this.decodeString();
    }
    case ARRAY_CODE: {
      return this.decodeArray();
    }
    case OBJECT_CODE: {
      return this.decodeObject();
    }
    case DEFINITION_CODE: {
      return this.decodeDefinitions();
    }
    case CONST_CODE: {
      return this.decodeConst();
    }
  }
};
PackJSON.prototype.encodeSpec = function (value) {
  this.buffer.pushChunk(CODE_SIZE, SPEC_CODE);
  this.buffer.pushChunk(SPEC_SIZE, SPEC_LITERALS.indexOf(value));
};
PackJSON.prototype.decodeSpec = function () {
  return SPEC_LITERALS[this.buffer.readChunk(SPEC_SIZE)];
};

PackJSON.prototype.encodeNumber = function (value) {
  if (this.definitions?.indexOf(value) > -1) {
    return this.encodeConst(this.sharedNumbersDict[value]);
  }
  this.buffer.pushChunk(CODE_SIZE, NUMBER_CODE);
  if (Number.isInteger(value)) {
    this.buffer.pushChunk(NUMBER_TYPE_SIZE, NUMBER_INTEGER_TYPE);
    this.buffer.pushChunk(1, value < 0);
    value = Math.abs(value);
    this.buffer.pushChunk(MAX_INT_SIZE.toString(2).length, value.toString(2).length);
    value
      .toString(32)
      .split("")
      .forEach((b32, idx) => {
        const val = Number.parseInt(b32, 32);

        this.buffer.pushChunk(idx ? 5 : val.toString(2).length, val);
      });
  } else {
    const stringValue = JSON.stringify(value);

    if (stringValue.length * NUM_CODES_SIZE < 64) {
      this.buffer.pushChunk(NUMBER_TYPE_SIZE, NUMBER_STRING_TYPE);
      this.buffer.pushChunk((64 / NUM_CODES_SIZE - 1).toString(2).length, stringValue.length);
      stringValue.split("").forEach((ch) => {
        this.buffer.pushChunk(NUM_CODES_SIZE, NUM_CODES.indexOf(ch));
      });
    } else {
      const bytes = NumberToBytes(value);

      this.buffer.pushChunk(NUMBER_TYPE_SIZE, NUMBER_FLOAT_TYPE);
      bytes.forEach((byte) => this.buffer.pushChunk(8, byte));
    }
  }
};
PackJSON.prototype.decodeNumber = function () {
  const type = this.buffer.readChunk(NUMBER_TYPE_SIZE);

  switch (type) {
    case NUMBER_INTEGER_TYPE: {
      const sign = this.buffer.readChunk(1);
      const size = this.buffer.readChunk(MAX_INT_SIZE.toString(2).length);
      const b32 = Array.apply(null, new Array(Math.ceil(size / 5)))
        .map((v, idx) => this.buffer.readChunk(idx ? 5 : size % 5 || 5).toString(32))
        .join("");

      return (sign ? -1 : 1) * Number.parseInt(b32, 32);
    }
    case NUMBER_STRING_TYPE: {
      const length = this.buffer.readChunk((64 / NUM_CODES_SIZE - 1).toString(2).length);

      return JSON.parse(
        Array.apply(null, new Array(length))
          .map(() => NUM_CODES[this.buffer.readChunk(NUM_CODES_SIZE)])
          .join(""),
      );
    }
    case NUMBER_FLOAT_TYPE: {
      const bytes = this.buffer.readBytes(8);

      return NumberFromBytes(bytes);
    }
  }
};

PackJSON.prototype.encodeString = function (value) {
  if (this.definitions?.indexOf(value) > -1) {
    return this.encodeConst(this.sharedStringsDict[value]);
  }
  value = this.packInConstants(value);
  this.buffer.pushChunk(CODE_SIZE, STRING_CODE);
  const knownCharsCount = value.split("").filter((ch) => {
    const idx = CODES.indexOf(ch);

    return idx > -1 && idx < CODES.length - 1;
  }).length;
  const unknownCharsCount = value.length - knownCharsCount;
  const potentialInfrequentCharsStringSize = knownCharsCount * 6 + unknownCharsCount * (6 + 16);
  const potentialOnlyCodesStringSize = value.length * 16;
  const potentialMarkedCharsStringSize = knownCharsCount * 7 + unknownCharsCount * 17;
  const minSize = Math.min(
    potentialInfrequentCharsStringSize,
    potentialOnlyCodesStringSize,
    potentialMarkedCharsStringSize,
  );

  switch (minSize) {
    case potentialInfrequentCharsStringSize: {
      this.buffer.pushChunk(STRING_TYPE_SIZE, INFREQUENT_CODES_STRING_TYPE);
      this.encodeStringLen(value);
      value.split("").forEach((ch) => {
        const idx = CODES.indexOf(ch);

        if (idx > -1 && idx < CODES.length - 1) {
          this.buffer.pushChunk(6, idx);
        } else {
          this.buffer.pushChunk(6, CODES.length - 1);
          this.buffer.pushChunk(16, ch.charCodeAt(0));
        }
      });
      break;
    }
    case potentialOnlyCodesStringSize: {
      this.buffer.pushChunk(STRING_TYPE_SIZE, ONLY_CODES_STRING_TYPE);
      this.encodeStringLen(value);
      value.split("").forEach((ch) => {
        this.buffer.pushChunk(16, ch.charCodeAt(0));
      });
      break;
    }
    case potentialMarkedCharsStringSize: {
      this.buffer.pushChunk(STRING_TYPE_SIZE, MARKED_CHARS_STRING_TYPE);
      this.encodeStringLen(value);
      value.split("").forEach((ch) => {
        const idx = CODES.indexOf(ch);

        if (idx > -1) {
          this.buffer.pushChunk(1, 0);
          this.buffer.pushChunk(6, idx);
        } else {
          this.buffer.pushChunk(1, 1);
          this.buffer.pushChunk(16, ch.charCodeAt(0));
        }
      });
      break;
    }
  }
};
PackJSON.prototype.encodeStringLen = function (value) {
  const stringLengthParts = value.length.toString(1 << STRING_LEN_BLOCK_SIZE).split("");

  stringLengthParts.forEach((lenBlock, idx) => {
    this.buffer.pushChunk(STRING_LEN_BLOCK_SIZE, Number.parseInt(lenBlock, 1 << STRING_LEN_BLOCK_SIZE));
    this.buffer.pushChunk(1, idx === stringLengthParts.length - 1); // stop chain marker
  });
};

PackJSON.prototype.decodeString = function () {
  const value = this._decodeString();

  return this.resolveConstants(value);
};

PackJSON.prototype._decodeString = function () {
  const stingType = this.buffer.readChunk(STRING_TYPE_SIZE);

  switch (stingType) {
    case INFREQUENT_CODES_STRING_TYPE: {
      const length = this.decodeStringLen();

      return Array.apply(null, new Array(length))
        .map(() => {
          const idx = this.buffer.readChunk(6);

          if (idx > -1 && idx < CODES.length - 2) {
            return CODES[idx];
          }
          if (idx === CODES.length - 1) {
            return String.fromCharCode(this.buffer.readChunk(16));
          }
        })
        .join("");
    }
    case ONLY_CODES_STRING_TYPE: {
      const length = this.decodeStringLen();

      return Array.apply(null, new Array(length))
        .map(() => String.fromCharCode(this.buffer.readChunk(16)))
        .join("");
    }
    case MARKED_CHARS_STRING_TYPE: {
      const length = this.decodeStringLen();

      return Array.apply(null, new Array(length))
        .map(() => {
          const isCode = this.buffer.readChunk(1);

          if (!isCode) {
            return CODES[this.buffer.readChunk(6)];
          }
          return String.fromCharCode(this.buffer.readChunk(16));
        })
        .join("");
    }
  }
};
PackJSON.prototype.decodeStringLen = function () {
  const stringLengthParts = [];
  let shouldStop = false;

  do {
    stringLengthParts.push(this.buffer.readChunk(STRING_LEN_BLOCK_SIZE).toString(1 << STRING_LEN_BLOCK_SIZE));
    shouldStop = this.buffer.readChunk(1);
  } while (!shouldStop);
  return Number.parseInt(stringLengthParts.join(""), 1 << STRING_LEN_BLOCK_SIZE);
};

PackJSON.prototype.packInConstants = function (value) {
  const re = /\./g;

  value = value.replace(re, ".-");
  this.definitions.forEach((definition, idx) => {
    const re = new RegExp(definition, "g");

    value = value.replace(re, `.${idx}`);
  });
  return value;
};

PackJSON.prototype.resolveConstants = function (value) {
  this.definitions.forEach((definition, idx) => {
    const re = new RegExp(`\\.${idx}`, "g");

    value = value.replace(re, definition);
  });
  const re = /\.-/g;

  value = value.replace(re, ".");
  return value;
};

PackJSON.prototype.pushStopCode = function () {
  this.buffer.pushChunk(CODE_SIZE, SPEC_CODE);
  this.buffer.pushChunk(SPEC_SIZE, 0);
};

PackJSON.prototype.encodeArray = function (value) {
  this.buffer.pushChunk(CODE_SIZE, ARRAY_CODE);
  const len = value.length;

  for (let i = 0; i < len; i++) {
    this.encode(value[i]);
  }
  this.pushStopCode();
};

PackJSON.prototype.decodeArray = function () {
  const res = [];

  while (!(this.buffer.readChunk(CODE_SIZE + SPEC_SIZE) === 0)) {
    this.buffer.seek(this.buffer.pos - (CODE_SIZE + SPEC_SIZE));
    res.push(this.decode());
  }
  return res;
};

PackJSON.prototype.encodeObject = function (value) {
  this.buffer.pushChunk(CODE_SIZE, OBJECT_CODE);
  for (const [key, val] of Object.entries(value)) {
    this.encode(key);
    this.encode(val);
  }
  this.pushStopCode();
};

PackJSON.prototype.decodeObject = function () {
  const res = {};

  while (!(this.buffer.readChunk(CODE_SIZE + SPEC_SIZE) === 0)) {
    this.buffer.seek(this.buffer.pos - (CODE_SIZE + SPEC_SIZE));
    res[this.decode()] = this.decode();
  }
  return res;
};

PackJSON.prototype.encodeDefinitions = function () {
  const definitions = [];

  this.definitions = [];
  [this.sharedNumbersDict, this.sharedStringsDict].forEach((dictionary) => {
    Object.entries(dictionary).forEach(([value, idx]) => {
      definitions[idx] = value;
    });
  });
  if (!definitions.length) return;
  this.buffer.pushChunk(CODE_SIZE, DEFINITION_CODE);
  this.buffer.pushChunk(DEFINITION_TYPE_SIZE, DICT_DEFINITION_TYPE);
  this.definitionIndexSize = Math.ceil(Math.log(definitions.length) / Math.log(2));
  definitions.forEach((definition) => {
    this.encode(definition);
  });
  this.definitions = definitions;
  this.pushStopCode();
};

PackJSON.prototype.decodeDefinitions = function () {
  this.buffer.readChunk(DEFINITION_TYPE_SIZE);
  while (!(this.buffer.readChunk(CODE_SIZE + SPEC_SIZE) === 0)) {
    this.buffer.seek(this.buffer.pos - (CODE_SIZE + SPEC_SIZE));
    this.definitions.push(this.decode());
  }
  this.definitionIndexSize = Math.ceil(Math.log(this.definitions.length) / Math.log(2));
  // decode next as if there weren't any definitions
  return this.decode();
};

PackJSON.prototype.encodeConst = function (idx) {
  this.buffer.pushChunk(CODE_SIZE, CONST_CODE);
  this.buffer.pushChunk(this.definitionIndexSize, idx);
};

PackJSON.prototype.decodeConst = function () {
  const definitionIndex = this.buffer.readChunk(this.definitionIndexSize);

  return this.definitions[definitionIndex];
};

const packJSON = new PackJSON();

export { PackJSON, packJSON };