/**
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */

import {
  serializeBooleanColumn,
  serializeInt32Column,
  serializeInt64Column,
  serializeFloatColumn,
  serializeDoubleColumn,
  serializeTextColumn,
  serializeTimestampColumn,
  serializeDateColumn,
  serializeBlobColumn,
  serializeTimestamps,
  serializeColumnFast,
  writeInt64BE,
} from "../../src/utils/FastSerializer";
import { globalBufferPool } from "../../src/utils/BufferPool";

describe("FastSerializer", () => {
  afterEach(() => {
    // Clear buffer pool after each test to avoid interference
    globalBufferPool.clear();
  });

  describe("Boolean Serialization", () => {
    it("should serialize boolean values correctly", () => {
      const values = [true, false, true, null, undefined];
      const buffer = serializeBooleanColumn(values);

      expect(buffer.length).toBe(5);
      expect(buffer[0]).toBe(1); // true
      expect(buffer[1]).toBe(0); // false
      expect(buffer[2]).toBe(1); // true
      expect(buffer[3]).toBe(0); // null -> 0
      expect(buffer[4]).toBe(0); // undefined -> 0
    });
  });

  describe("INT32 Serialization", () => {
    it("should serialize INT32 values correctly", () => {
      const values = [100, -200, 0, null, undefined];
      const buffer = serializeInt32Column(values);

      expect(buffer.length).toBe(20); // 5 * 4 bytes
      expect(buffer.readInt32BE(0)).toBe(100);
      expect(buffer.readInt32BE(4)).toBe(-200);
      expect(buffer.readInt32BE(8)).toBe(0);
      expect(buffer.readInt32BE(12)).toBe(0); // null -> 0
      expect(buffer.readInt32BE(16)).toBe(0); // undefined -> 0
    });
  });

  describe("INT64 Serialization", () => {
    it("should serialize INT64 values correctly", () => {
      const values = [BigInt(1000), BigInt(-2000), 0, null, undefined];
      const buffer = serializeInt64Column(values);

      expect(buffer.length).toBe(40); // 5 * 8 bytes
      expect(buffer.readBigInt64BE(0)).toBe(BigInt(1000));
      expect(buffer.readBigInt64BE(8)).toBe(BigInt(-2000));
      expect(buffer.readBigInt64BE(16)).toBe(BigInt(0));
      expect(buffer.readBigInt64BE(24)).toBe(BigInt(0)); // null -> 0
      expect(buffer.readBigInt64BE(32)).toBe(BigInt(0)); // undefined -> 0
    });
  });

  describe("BigInt-free INT64 hi/lo writes", () => {
    const roundTrip = (v: number | bigint): bigint => {
      const buf = Buffer.allocUnsafe(8);
      writeInt64BE(buf, v, 0);
      return buf.readBigInt64BE(0);
    };

    it("should write positive numbers correctly", () => {
      expect(roundTrip(0)).toBe(BigInt(0));
      expect(roundTrip(1)).toBe(BigInt(1));
      expect(roundTrip(0xffffffff)).toBe(BigInt(0xffffffff)); // 32-bit boundary
      expect(roundTrip(0x100000000)).toBe(BigInt("4294967296"));
      expect(roundTrip(Number.MAX_SAFE_INTEGER)).toBe(BigInt(Number.MAX_SAFE_INTEGER));
    });

    it("should write negative numbers correctly (two's complement)", () => {
      expect(roundTrip(-1)).toBe(BigInt(-1));
      expect(roundTrip(-2000)).toBe(BigInt(-2000));
      expect(roundTrip(-0x100000000)).toBe(BigInt("-4294967296"));
      expect(roundTrip(-0x100000001)).toBe(BigInt("-4294967297"));
      expect(roundTrip(Number.MIN_SAFE_INTEGER)).toBe(BigInt(Number.MIN_SAFE_INTEGER));
    });

    it("should handle BigInt inputs", () => {
      expect(roundTrip(BigInt(1000))).toBe(BigInt(1000));
      expect(roundTrip(BigInt(-2000))).toBe(BigInt(-2000));
      expect(roundTrip(BigInt("-9223372036854775808"))).toBe(BigInt("-9223372036854775808")); // i64 min
      expect(roundTrip(BigInt("9223372036854775807"))).toBe(BigInt("9223372036854775807")); // i64 max
    });

    it("should match legacy BigInt output for INT64 columns with negatives", () => {
      const values = [
        Number.MIN_SAFE_INTEGER,
        -1,
        -0x100000000,
        0,
        0xffffffff,
        Number.MAX_SAFE_INTEGER,
        BigInt(-42),
      ];
      const buffer = serializeInt64Column(values);
      const legacy = Buffer.alloc(values.length * 8);
      values.forEach((v, i) => legacy.writeBigInt64BE(BigInt(v), i * 8));
      expect(buffer.equals(legacy)).toBe(true);
    });

    it("should serialize negative timestamps (pre-1970) correctly", () => {
      const values = [-1, -86400000, 0, 1700000000000];
      const buffer = serializeTimestampColumn(values);
      values.forEach((v, i) => {
        expect(buffer.readBigInt64BE(i * 8)).toBe(BigInt(v));
      });
      // serializeTimestamps (time column) too
      const tsBuffer = serializeTimestamps(values as number[]);
      values.forEach((v, i) => {
        expect(tsBuffer.readBigInt64BE(i * 8)).toBe(BigInt(v));
      });
    });
  });

  describe("String encode cache", () => {
    it("should reuse encoding for repeated strings (TAG-like column)", () => {
      const values = Array.from({ length: 100 }, () => "device_001");
      const buffer = serializeTextColumn(values);
      let offset = 0;
      for (let i = 0; i < 100; i++) {
        const len = buffer.readInt32BE(offset);
        offset += 4;
        expect(buffer.toString("utf8", offset, offset + len)).toBe("device_001");
        offset += len;
      }
      expect(offset).toBe(buffer.length);
    });

    it("should not wrongly reuse cache for different strings", () => {
      const values = ["aaa", "aaa", "bbb", "aaa", "cc", "你好", "你好", "cc"];
      const buffer = serializeTextColumn(values);
      let offset = 0;
      for (const v of values) {
        const expected = Buffer.from(v, "utf8");
        const len = buffer.readInt32BE(offset);
        offset += 4;
        expect(len).toBe(expected.length);
        expect(buffer.toString("utf8", offset, offset + len)).toBe(v);
        offset += len;
      }
      expect(offset).toBe(buffer.length);
    });

    it("should handle nulls interleaved with cached strings", () => {
      const values = ["x", null, "x", undefined, "y"];
      const buffer = serializeTextColumn(values);
      let offset = 0;
      const expected = ["x", "", "x", "", "y"];
      for (const v of expected) {
        const len = buffer.readInt32BE(offset);
        offset += 4;
        expect(buffer.toString("utf8", offset, offset + len)).toBe(v);
        offset += len;
      }
      expect(offset).toBe(buffer.length);
    });
  });

  describe("FLOAT Serialization", () => {
    it("should serialize FLOAT values correctly", () => {
      const values = [1.5, -2.5, 0.0, null, undefined];
      const buffer = serializeFloatColumn(values);

      expect(buffer.length).toBe(20); // 5 * 4 bytes
      expect(buffer.readFloatBE(0)).toBeCloseTo(1.5);
      expect(buffer.readFloatBE(4)).toBeCloseTo(-2.5);
      expect(buffer.readFloatBE(8)).toBe(0.0);
      expect(buffer.readFloatBE(12)).toBe(0.0); // null -> 0
      expect(buffer.readFloatBE(16)).toBe(0.0); // undefined -> 0
    });
  });

  describe("DOUBLE Serialization", () => {
    it("should serialize DOUBLE values correctly", () => {
      const values = [1.5, -2.5, 0.0, null, undefined];
      const buffer = serializeDoubleColumn(values);

      expect(buffer.length).toBe(40); // 5 * 8 bytes
      expect(buffer.readDoubleBE(0)).toBe(1.5);
      expect(buffer.readDoubleBE(8)).toBe(-2.5);
      expect(buffer.readDoubleBE(16)).toBe(0.0);
      expect(buffer.readDoubleBE(24)).toBe(0.0); // null -> 0
      expect(buffer.readDoubleBE(32)).toBe(0.0); // undefined -> 0
    });
  });

  describe("TEXT Serialization", () => {
    it("should serialize TEXT values correctly", () => {
      const values = ["hello", "world", "", null, undefined];
      const buffer = serializeTextColumn(values);

      // Read first string
      let offset = 0;
      const len1 = buffer.readInt32BE(offset);
      offset += 4;
      const str1 = buffer.toString("utf8", offset, offset + len1);
      offset += len1;
      expect(str1).toBe("hello");

      // Read second string
      const len2 = buffer.readInt32BE(offset);
      offset += 4;
      const str2 = buffer.toString("utf8", offset, offset + len2);
      expect(str2).toBe("world");
    });

    it("should handle UTF-8 multibyte characters", () => {
      const values = ["你好", "世界"];
      const buffer = serializeTextColumn(values);

      let offset = 0;
      const len1 = buffer.readInt32BE(offset);
      offset += 4;
      const str1 = buffer.toString("utf8", offset, offset + len1);
      expect(str1).toBe("你好");
    });
  });

  describe("TIMESTAMP Serialization", () => {
    it("should serialize TIMESTAMP values correctly", () => {
      const now = Date.now();
      const values = [now, new Date(now + 1000), null, undefined];
      const buffer = serializeTimestampColumn(values);

      expect(buffer.length).toBe(32); // 4 * 8 bytes
      expect(buffer.readBigInt64BE(0)).toBe(BigInt(now));
      expect(buffer.readBigInt64BE(8)).toBe(BigInt(now + 1000));
      expect(buffer.readBigInt64BE(16)).toBe(BigInt(0)); // null -> 0
      expect(buffer.readBigInt64BE(24)).toBe(BigInt(0)); // undefined -> 0
    });
  });

  describe("DATE Serialization", () => {
    it("should serialize DATE values as INT32 yyyyMMdd", () => {
      const date1 = new Date("2024-01-01");
      const values = [date1, 20241231, null, undefined];
      const buffer = serializeDateColumn(values);

      expect(buffer.length).toBe(16); // 4 * 4 bytes
      expect(buffer.readInt32BE(0)).toBe(20240101); // yyyyMMdd, NOT days since epoch
      expect(buffer.readInt32BE(4)).toBe(20241231); // numbers pass through unchanged
      expect(buffer.readInt32BE(8)).toBe(0); // null -> 0
      expect(buffer.readInt32BE(12)).toBe(0); // undefined -> 0
    });

    it("should produce exact wire bytes for 2026-07-13", () => {
      // IoTDB DATE wire format: INT32 yyyyMMdd, big-endian
      // 20260713 = 0x01352769
      const buffer = serializeDateColumn([new Date("2026-07-13")]);
      expect(Array.from(buffer)).toEqual([0x01, 0x35, 0x27, 0x69]);
    });

    it("should reject invalid DATE values", () => {
      expect(() => serializeDateColumn([20230229])).toThrow(/Invalid DATE/); // not a leap year
      expect(() => serializeDateColumn([new Date(NaN)])).toThrow(
        /Invalid DATE/,
      );
    });
  });

  describe("BLOB Serialization", () => {
    it("should serialize BLOB values correctly", () => {
      const blob1 = Buffer.from([1, 2, 3]);
      const blob2 = Buffer.from([4, 5, 6, 7]);
      const values = [blob1, blob2, null];
      const buffer = serializeBlobColumn(values);

      // Read first blob
      let offset = 0;
      const len1 = buffer.readInt32BE(offset);
      offset += 4;
      expect(len1).toBe(3);
      const data1 = buffer.subarray(offset, offset + len1);
      offset += len1;
      expect(data1).toEqual(blob1);

      // Read second blob
      const len2 = buffer.readInt32BE(offset);
      offset += 4;
      expect(len2).toBe(4);
      const data2 = buffer.subarray(offset, offset + len2);
      expect(data2).toEqual(blob2);
    });
  });

  describe("Timestamp Array Serialization", () => {
    it("should serialize timestamp array correctly", () => {
      const timestamps = [1000, 2000, 3000];
      const buffer = serializeTimestamps(timestamps);

      expect(buffer.length).toBe(24); // 3 * 8 bytes
      expect(buffer.readBigInt64BE(0)).toBe(BigInt(1000));
      expect(buffer.readBigInt64BE(8)).toBe(BigInt(2000));
      expect(buffer.readBigInt64BE(16)).toBe(BigInt(3000));
    });

    it("should throw error for invalid timestamp", () => {
      const timestamps = [1000, NaN, 3000];
      expect(() => serializeTimestamps(timestamps)).toThrow("Invalid timestamp");
    });
  });

  describe("Fast Column Serialization Dispatcher", () => {
    it("should dispatch to correct serializer for each type", () => {
      // BOOLEAN (0)
      const boolBuffer = serializeColumnFast([true, false], 0);
      expect(boolBuffer.length).toBe(2);

      // INT32 (1)
      const int32Buffer = serializeColumnFast([100, 200], 1);
      expect(int32Buffer.length).toBe(8);

      // INT64 (2)
      const int64Buffer = serializeColumnFast([100, 200], 2);
      expect(int64Buffer.length).toBe(16);

      // FLOAT (3)
      const floatBuffer = serializeColumnFast([1.5, 2.5], 3);
      expect(floatBuffer.length).toBe(8);

      // DOUBLE (4)
      const doubleBuffer = serializeColumnFast([1.5, 2.5], 4);
      expect(doubleBuffer.length).toBe(16);

      // TEXT (5)
      const textBuffer = serializeColumnFast(["hello", "world"], 5);
      expect(textBuffer.length).toBeGreaterThan(0);

      // TIMESTAMP (8)
      const tsBuffer = serializeColumnFast([1000, 2000], 8);
      expect(tsBuffer.length).toBe(16);

      // DATE (9) - values must be valid yyyyMMdd integers
      const dateBuffer = serializeColumnFast([20240101, 20241231], 9);
      expect(dateBuffer.length).toBe(8);

      // BLOB (10)
      const blobBuffer = serializeColumnFast([Buffer.from([1, 2])], 10);
      expect(blobBuffer.length).toBeGreaterThan(0);

      // STRING (11)
      const stringBuffer = serializeColumnFast(["test"], 11);
      expect(stringBuffer.length).toBeGreaterThan(0);
    });

    it("should throw error for unsupported type", () => {
      expect(() => serializeColumnFast([1, 2, 3], 99)).toThrow("Unsupported data type");
    });
  });

  describe("Buffer Pool Integration", () => {
    it("should no longer use the deprecated buffer pool", () => {
      const statsInitial = globalBufferPool.getStats();

      // Large buffers used to trigger pooling; serializers now allocate directly
      const largeValues = Array.from({ length: 300 }, (_, i) => i); // 300 * 4 = 1200 bytes
      serializeInt32Column(largeValues);
      serializeDoubleColumn(largeValues); // 300 * 8 = 2400 bytes

      const statsFinal = globalBufferPool.getStats();

      // The pool is deprecated: no acquire() calls should be made
      expect(statsFinal.allocations + statsFinal.hits).toBe(
        statsInitial.allocations + statsInitial.hits,
      );
    });
  });
});