import assert from "node:assert/strict";
import { test } from "vitest";
import { applyManticoreDdlColumnExtras, buildStructureTargetLabel, canEditManticoreColumnProperties, combineDataTypeForDatabase, createColumnDrafts, createIndexDrafts, generateIndexName, generateUniqueIndexName, getColumnEditorControls, getDataTypeOptions, isProtectedManticoreIdColumn, normalizeDataTypeParams, parseExtraToColumnExtra, toColumnNames } from "../../apps/desktop/src/lib/tableStructureEditorState.ts";
import type { ColumnInfo, IndexInfo } from "../../apps/desktop/src/types/database.ts";

const columns: ColumnInfo[] = [
  {
    name: "id",
    data_type: "bigint",
    is_nullable: false,
    column_default: null,
    is_primary_key: true,
    extra: "auto_increment",
    comment: "identifier",
  },
  {
    name: "name",
    data_type: "varchar(120)",
    is_nullable: true,
    column_default: "'guest'",
    is_primary_key: false,
    extra: null,
    comment: null,
  },
];

const indexes: IndexInfo[] = [
  { name: "PRIMARY", columns: ["id"], is_unique: true, is_primary: true },
  { name: "idx_name", columns: ["name"], is_unique: false, is_primary: false },
];

test("creates editable column drafts from column metadata", () => {
  const drafts = createColumnDrafts(columns, "mysql");

  assert.deepEqual(
    drafts.map((draft) => ({
      id: draft.id,
      name: draft.name,
      dataType: draft.dataType,
      isNullable: draft.isNullable,
      defaultValue: draft.defaultValue,
      comment: draft.comment,
      isPrimaryKey: draft.isPrimaryKey,
      extra: draft.extra,
      originalPosition: draft.originalPosition,
      markedForDrop: draft.markedForDrop,
      originalName: draft.original?.name,
    })),
    [
      {
        id: "existing:id",
        name: "id",
        dataType: "bigint",
        isNullable: false,
        defaultValue: "",
        comment: "identifier",
        isPrimaryKey: true,
        extra: { autoIncrement: true },
        originalPosition: 0,
        markedForDrop: false,
        originalName: "id",
      },
      {
        id: "existing:name",
        name: "name",
        dataType: "varchar(120)",
        isNullable: true,
        defaultValue: "'guest'",
        comment: "",
        isPrimaryKey: false,
        extra: {},
        originalPosition: 1,
        markedForDrop: false,
        originalName: "name",
      },
    ],
  );
});

test("applies manticore column properties from ddl", () => {
  const manticoreColumns: ColumnInfo[] = [
    { name: "name", data_type: "string", is_nullable: true, column_default: null, is_primary_key: false, extra: null, comment: null },
    { name: "code", data_type: "string", is_nullable: true, column_default: null, is_primary_key: false, extra: null, comment: null },
    { name: "resource", data_type: "json", is_nullable: true, column_default: null, is_primary_key: false, extra: null, comment: null },
  ];
  const ddl = `CREATE TABLE materials (
name string indexed attribute,
code string attribute,
resource json secondary_index='1'
)`;

  const drafts = createColumnDrafts(applyManticoreDdlColumnExtras(manticoreColumns, ddl), "manticoresearch");

  assert.deepEqual(
    drafts.map((draft) => ({ name: draft.name, dataType: draft.dataType, extra: draft.extra })),
    [
      { name: "name", dataType: "string", extra: { manticoreIndexed: true, manticoreAttribute: true } },
      { name: "code", dataType: "string", extra: { manticoreAttribute: true } },
      { name: "resource", dataType: "json", extra: { manticoreSecondaryIndex: true } },
    ],
  );
});

test("parses MySQL extra string to ColumnExtra", () => {
  assert.deepEqual(parseExtraToColumnExtra("auto_increment", "mysql"), { autoIncrement: true });
  assert.deepEqual(parseExtraToColumnExtra("on update CURRENT_TIMESTAMP", "mysql"), {
    onUpdateCurrentTimestamp: true,
  });
  assert.deepEqual(parseExtraToColumnExtra("auto_increment on update current_timestamp", "mysql"), {
    autoIncrement: true,
    onUpdateCurrentTimestamp: true,
  });
  assert.deepEqual(parseExtraToColumnExtra(null, "mysql"), {});
  assert.deepEqual(parseExtraToColumnExtra("", "mysql"), {});
});

test("parses PostgreSQL extra string to ColumnExtra", () => {
  assert.deepEqual(parseExtraToColumnExtra("generated by default as identity", "postgres"), {
    identity: { generation: "BY DEFAULT" },
  });
  assert.deepEqual(parseExtraToColumnExtra("generated by default as identity", "opengauss"), {
    identity: { generation: "BY DEFAULT" },
  });
  assert.deepEqual(parseExtraToColumnExtra("generated by default as identity", "gaussdb"), {
    identity: { generation: "BY DEFAULT" },
  });
  assert.deepEqual(parseExtraToColumnExtra("GENERATED ALWAYS AS IDENTITY", "postgres"), {
    identity: { generation: "ALWAYS" },
  });
  assert.deepEqual(parseExtraToColumnExtra("generated always as identity (start with 10 increment by 2)", "postgres"), {
    identity: { generation: "ALWAYS", seed: 10, increment: 2 },
  });
});

test("parses SQL Server identity extra string to ColumnExtra", () => {
  assert.deepEqual(parseExtraToColumnExtra("identity(1,1)", "sqlserver"), {
    autoIncrement: true,
    identity: { seed: 1, increment: 1 },
  });
  assert.deepEqual(parseExtraToColumnExtra("IDENTITY(100, 5)", "sqlserver"), {
    autoIncrement: true,
    identity: { seed: 100, increment: 5 },
  });
});

test("parses Manticore Search text properties to ColumnExtra", () => {
  assert.deepEqual(parseExtraToColumnExtra("stored indexed", "manticoresearch"), {
    manticoreStored: true,
    manticoreIndexed: true,
  });
  assert.deepEqual(parseExtraToColumnExtra("attribute indexed", "manticoresearch"), {
    manticoreAttribute: true,
    manticoreIndexed: true,
  });
  assert.deepEqual(parseExtraToColumnExtra("secondary_index='1'", "manticoresearch"), {
    manticoreSecondaryIndex: true,
  });
});

test("creates editable index drafts and splits pasted column lists", () => {
  const drafts = createIndexDrafts(indexes);

  assert.deepEqual(
    drafts.map((draft) => ({
      id: draft.id,
      name: draft.name,
      columns: draft.columns,
      isUnique: draft.isUnique,
      isPrimary: draft.isPrimary,
      originalName: draft.original?.name,
    })),
    [
      {
        id: "existing:PRIMARY",
        name: "PRIMARY",
        columns: ["id"],
        isUnique: true,
        isPrimary: true,
        originalName: "PRIMARY",
      },
      {
        id: "existing:idx_name",
        name: "idx_name",
        columns: ["name"],
        isUnique: false,
        isPrimary: false,
        originalName: "idx_name",
      },
    ],
  );
  assert.equal(toColumnNames(["id", "name"]), "id, name");
});

test("generates conventional index names from table and columns", () => {
  assert.equal(generateIndexName("A", ["B"]), "A_B_IDX");
  assert.equal(generateIndexName("order item", ["customer-id", "created_at"]), "ORDER_ITEM_CUSTOMER_ID_CREATED_AT_IDX");
  assert.equal(generateIndexName("users", ["email"], 12), "USERS_EM_IDX");
});

test("generates unique index names when automatic name already exists", () => {
  assert.equal(generateUniqueIndexName("users", ["email"], ["USERS_EMAIL_IDX"]), "USERS_EMAIL_IDX_2");
  assert.equal(generateUniqueIndexName("users", ["email"], ["users_email_idx", "USERS_EMAIL_IDX_2"]), "USERS_EMAIL_IDX_3");
});

test("structure editor target label omits duplicate database and schema", () => {
  assert.equal(buildStructureTargetLabel("online-clickhouse", "testdb", "testdb", "users"), "online-clickhouse / testdb / users");
  assert.equal(buildStructureTargetLabel("online-postgres", "app", "public", "users"), "online-postgres / app / public / users");
});

test("normalizes temporal precision when combining data types", () => {
  assert.equal(combineDataTypeForDatabase("mysql", "timestamp", "255"), "timestamp");
  assert.equal(combineDataTypeForDatabase("mysql", "timestamp", "3"), "timestamp(3)");
  assert.equal(combineDataTypeForDatabase("mysql", "varchar", "255"), "varchar(255)");
  assert.equal(normalizeDataTypeParams("oracle", "timestamp", "9"), "9");
  assert.equal(normalizeDataTypeParams("oracle", "timestamp", "10"), "");
});

test("returns data type options for compatible table structure editors", () => {
  assert.deepEqual(getDataTypeOptions("dameng"), getDataTypeOptions("oracle"));
  assert.deepEqual(getDataTypeOptions("gaussdb"), getDataTypeOptions("postgres"));
  assert.deepEqual(getDataTypeOptions("doris"), getDataTypeOptions("mysql"));
  assert.equal(getDataTypeOptions("dameng").includes("varchar2"), true);
  assert.equal(getDataTypeOptions("sqlserver").includes("nvarchar"), true);
});

test("returns Manticore Search data type options", () => {
  assert.deepEqual(getDataTypeOptions("manticoresearch"), ["text", "string", "int", "bit", "bigint", "bool", "timestamp", "float", "json", "float_vector", "multi", "mva"]);
});

test("returns Manticore Search column editor controls", () => {
  assert.deepEqual(getColumnEditorControls("manticoresearch"), {
    length: true,
    nullable: false,
    primaryKey: false,
    defaultValue: false,
    comment: false,
  });
  assert.equal(getColumnEditorControls("mysql").nullable, true);
});

test("protects Manticore Search id column from destructive structure edits", () => {
  assert.equal(isProtectedManticoreIdColumn("manticoresearch", "id"), true);
  assert.equal(isProtectedManticoreIdColumn("manticoresearch", "ID"), true);
  assert.equal(isProtectedManticoreIdColumn("manticoresearch", "name"), false);
  assert.equal(isProtectedManticoreIdColumn("mysql", "id"), false);
});

test("allows Manticore Search column properties only before the column exists", () => {
  assert.equal(canEditManticoreColumnProperties("manticoresearch", false), true);
  assert.equal(canEditManticoreColumnProperties("manticoresearch", true), false);
  assert.equal(canEditManticoreColumnProperties("mysql", false), false);
});