'use strict';

const { StringDecoder } = require('string_decoder');
const { types } = require('util');

const BUFFER_BYTES = 64 * 1024;

// 读取时直接构造容器和正文，不先拼接整份 JSON 原文。
function createJsonReader(fs, filename) {
  const fd = fs.openSync(filename, 'r');
  const buffer = Buffer.allocUnsafe(BUFFER_BYTES);
  let index = 0;
  let length = 0;
  let eof = false;
  let closed = false;

  function available() {
    if (index < length) return true;
    if (eof) return false;
    length = fs.readSync(fd, buffer, 0, buffer.length, null);
    index = 0;
    eof = length === 0;
    return !eof;
  }

  function whitespace() {
    while (available()) {
      const ch = buffer[index];
      if (ch !== 32 && ch !== 9 && ch !== 10 && ch !== 13) break;
      index += 1;
    }
  }

  function peek() {
    whitespace();
    return available() ? buffer[index] : -1;
  }

  function invalid() {
    throw new SyntaxError('持久化 JSON 结构无效或意外结束');
  }

  function consume(expected) {
    if (peek() !== expected.charCodeAt(0)) invalid();
    index += 1;
  }

  function string() {
    consume('"');
    const parts = [];
    let pending = [];
    let pendingChars = 0;
    let decoder = new StringDecoder('utf8');
    function append(text) {
      if (!text) return;
      pending.push(text);
      pendingChars += text.length;
      if (pendingChars >= 8192) {
        parts.push(pending.join(''));
        pending = [];
        pendingChars = 0;
      }
    }
    while (available()) {
      const start = index;
      while (index < length && buffer[index] >= 32 && buffer[index] !== 34 && buffer[index] !== 92) index += 1;
      if (index > start) append(decoder.write(buffer.subarray(start, index)));
      if (index === length) continue;
      const ch = buffer[index++];
      if (ch < 32) invalid();
      // 转义字符与引号都是 ASCII，先结束前一段 UTF-8 解码。
      append(decoder.end());
      if (ch === 34) { parts.push(pending.join('')); return parts.join(''); }
      decoder = new StringDecoder('utf8');
      if (!available()) invalid();
      const escaped = buffer[index++];
      const simple = { 34: '"', 92: '\\', 47: '/', 98: '\b', 102: '\f', 110: '\n', 114: '\r', 116: '\t' };
      if (Object.prototype.hasOwnProperty.call(simple, escaped)) append(simple[escaped]);
      else if (escaped === 117) {
        let hex = '';
        for (let count = 0; count < 4; count += 1) {
          if (!available()) invalid();
          hex += String.fromCharCode(buffer[index++]);
        }
        if (!/^[0-9a-fA-F]{4}$/.test(hex)) invalid();
        append(String.fromCharCode(Number.parseInt(hex, 16)));
      } else invalid();
    }
    invalid();
  }

  function object(field) {
    consume('{');
    if (peek() === 125) { index += 1; return; }
    while (true) {
      if (peek() !== 34) invalid();
      const key = string();
      consume(':');
      field(key);
      if (peek() === 125) { index += 1; return; }
      consume(',');
    }
  }

  function array(item) {
    consume('[');
    if (peek() === 93) { index += 1; return; }
    while (true) {
      item(value());
      if (peek() === 93) { index += 1; return; }
      consume(',');
    }
  }

  function value() {
    const first = peek();
    if (first === 34) return string();
    if (first === 123) {
      const result = {};
      object(key => Object.defineProperty(result, key, {
        value: value(), enumerable: true, writable: true, configurable: true,
      }));
      return result;
    }
    if (first === 91) {
      const result = [];
      array(item => result.push(item));
      return result;
    }
    const parts = [];
    while (available()) {
      const start = index;
      while (index < length && ![44, 125, 93, 32, 9, 10, 13].includes(buffer[index])) index += 1;
      if (index > start) parts.push(buffer.toString('utf8', start, index));
      if (index < length) break;
    }
    const token = parts.join('');
    if (token === 'null') return null;
    if (token === 'true') return true;
    if (token === 'false') return false;
    if (!/^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?$/.test(token)) invalid();
    return Number(token);
  }

  return {
    value, object, array,
    end() { if (peek() !== -1) invalid(); },
    close() { if (!closed) { closed = true; fs.closeSync(fd); } },
  };
}

function readJsonSync(fs, filename) {
  const reader = createJsonReader(fs, filename);
  try {
    const result = reader.value();
    reader.end();
    return result;
  } finally {
    reader.close();
  }
}

// 与历史持久化既有 replacer 保持一致；toJSON 在项目类型转换之前执行。
function jsonValue(value, key) {
  if (value !== null && (typeof value === 'object' || typeof value === 'function' || typeof value === 'bigint')) {
    const toJSON = value.toJSON;
    if (typeof toJSON === 'function') value = toJSON.call(value, key);
  }
  if (typeof value === 'bigint') return String(value);
  if (value instanceof Map) value = Object.fromEntries(value);
  else if (value instanceof Set) value = [...value];
  if (value && typeof value === 'object') {
    if (types.isNumberObject(value)) value = Number(value);
    else if (types.isStringObject(value)) value = String(value);
    else if (types.isBooleanObject(value)) value = Boolean.prototype.valueOf.call(value);
    else if (types.isBigIntObject(value)) throw new TypeError('JSON 不支持包装的 bigint');
  }
  if (typeof value === 'number' && !Number.isFinite(value)) return null;
  if (value === 0) return 0;
  if (value === undefined || typeof value === 'function' || typeof value === 'symbol') return undefined;
  return value;
}

function cloneJsonValue(value) {
  const ancestors = new Set();
  function clone(item, key) {
    item = jsonValue(item, key);
    if (item === null || typeof item !== 'object') return item;
    if (ancestors.has(item)) throw new TypeError('JSON 不支持循环引用');
    ancestors.add(item);
    try {
      if (Array.isArray(item)) {
        const result = [];
        const length = item.length;
        for (let index = 0; index < length; index += 1) result.push(clone(item[index], String(index)) ?? null);
        return result;
      }
      const result = {};
      for (const name of Object.keys(item)) {
        const next = clone(item[name], name);
        if (next !== undefined) Object.defineProperty(result, name, {
          value: next, enumerable: true, writable: true, configurable: true,
        });
      }
      return result;
    } finally {
      ancestors.delete(item);
    }
  }
  return clone(value, '');
}

function writeJsonSync(fs, fd, value) {
  const ancestors = new Set();
  const output = Buffer.allocUnsafe(BUFFER_BYTES);
  let used = 0;
  function flush() {
    let offset = 0;
    while (offset < used) {
      const written = fs.writeSync(fd, output, offset, used - offset, null);
      if (!Number.isInteger(written) || written <= 0) throw new Error('持久化 JSON 写入未取得进展');
      offset += written;
    }
    used = 0;
  }
  function append(text) {
    const bytes = Buffer.from(text, 'utf8');
    for (let offset = 0; offset < bytes.length;) {
      const count = Math.min(output.length - used, bytes.length - offset);
      bytes.copy(output, used, offset, offset + count);
      offset += count;
      used += count;
      if (used === output.length) flush();
    }
  }
  function string(text) {
    append('"');
    for (let start = 0; start < text.length;) {
      let end = Math.min(text.length, start + 8192);
      // 不能在分段转义处拆开 UTF-16 代理对，否则会改变实际 JSON 字节。
      if (end < text.length && text.charCodeAt(end - 1) >= 0xd800 && text.charCodeAt(end - 1) <= 0xdbff
        && text.charCodeAt(end) >= 0xdc00 && text.charCodeAt(end) <= 0xdfff) end -= 1;
      append(JSON.stringify(text.slice(start, end)).slice(1, -1));
      start = end;
    }
    append('"');
  }
  function write(item, key, arrayItem = false, prepared = false) {
    if (!prepared) item = jsonValue(item, key);
    if (item === undefined) {
      if (arrayItem) { append('null'); return true; }
      return false;
    }
    if (item === null) append('null');
    else if (typeof item === 'string') string(item);
    else if (typeof item !== 'object') append(String(item));
    else {
      if (ancestors.has(item)) throw new TypeError('JSON 不支持循环引用');
      ancestors.add(item);
      try {
        if (Array.isArray(item)) {
          append('[');
          const length = item.length;
          for (let index = 0; index < length; index += 1) {
            if (index) append(',');
            write(item[index], String(index), true);
          }
          append(']');
        } else {
          append('{');
          let first = true;
          for (const name of Object.keys(item)) {
            // 每个字段只求值一次，避免 getter 或 toJSON 重复执行。
            const next = jsonValue(item[name], name);
            if (next === undefined) continue;
            if (!first) append(',');
            first = false;
            string(name);
            append(':');
            write(next, name, false, true);
          }
          append('}');
        }
      } finally {
        ancestors.delete(item);
      }
    }
    return true;
  }
  if (!write(value, '')) throw new TypeError('顶层值不可持久化为 JSON');
  flush();
}

// 合并输入已是规范 JSON 值；直接比较结构，避免为长正文制造序列化副本。
function jsonValueEqual(left, right) {
  if (left === right) return true;
  if (left === null || right === null || typeof left !== 'object' || typeof right !== 'object') return false;
  if (Array.isArray(left) !== Array.isArray(right)) return false;
  if (Array.isArray(left)) return left.length === right.length && left.every((item, index) => jsonValueEqual(item, right[index]));
  const keys = Object.keys(left);
  return keys.length === Object.keys(right).length && keys.every(key => Object.prototype.hasOwnProperty.call(right, key)
    && jsonValueEqual(left[key], right[key]));
}

module.exports = { createJsonReader, readJsonSync, writeJsonSync, cloneJsonValue, jsonValueEqual };