import { EnvironmentId } from "@t3tools/contracts";
import { describe, expect, it } from "vite-plus/test";
import {
  usagePriceCell,
  usagePriceTableChanges,
  usagePriceTableErrors,
  type UsagePriceDraft,
} from "./usagePriceTable";
import type { UsagePriceTarget } from "./usagePriceTargets";

const price = { inputCostPerMillionTokens: 2, outputCostPerMillionTokens: 8 };
const target = (name: string, prices: UsagePriceTarget["prices"]): UsagePriceTarget => ({
  environmentId: EnvironmentId.make(name),
  label: name,
  prices,
  unavailable: null,
});
const draft = (values: UsagePriceDraft["values"]): UsagePriceDraft => ({
  id: "model:example",
  model: "example",
  isNew: false,
  values,
});

describe("price table edits", () => {
  it("shows shared and mixed cells separately, and never treats missing settings as automatic", () => {
    const targets = [
      target("a", { example: price }),
      target("b", { example: { ...price, outputCostPerMillionTokens: 10 } }),
    ];
    expect(usagePriceCell(targets, "example", "inputCostPerMillionTokens").value).toBe("2");
    expect(usagePriceCell(targets, "example", "outputCostPerMillionTokens")).toEqual({
      value: "",
      placeholder: "Mixed",
    });
    expect(usagePriceCell(targets, "example", "cacheReadCostPerMillionTokens")).toEqual({
      value: "",
      placeholder: "Input rate",
    });
    expect(
      usagePriceCell([target("a", {})], "example", "inputCostPerMillionTokens").placeholder,
    ).toBe("Automatic");
    expect(
      usagePriceCell([targets[0]!, target("b", null)], "example", "inputCostPerMillionTokens")
        .placeholder,
    ).toBe("Unavailable");
  });

  it.each(["constructor", "toString", "__proto__"])(
    "handles an exact model ID named %s",
    (model) => {
      const environment = target("a", {});
      expect(usagePriceCell([environment], model, "inputCostPerMillionTokens")).toEqual({
        value: "",
        placeholder: "Automatic",
      });
      const result = usagePriceTableChanges(environment, [
        {
          ...draft({ inputCostPerMillionTokens: "2", outputCostPerMillionTokens: "8" }),
          model,
          isNew: true,
        },
      ]);
      expect(result.changes).toEqual([{ model, price }]);
      expect(
        usagePriceCell([target("a", { [model]: price })], model, "inputCostPerMillionTokens").value,
      ).toBe("2");
    },
  );

  it("changes only edited columns while preserving each environment's other prices and models", () => {
    const edits = [draft({ inputCostPerMillionTokens: "3" })];
    const a = usagePriceTableChanges(
      target("a", { example: { ...price, cacheReadCostPerMillionTokens: 0 }, untouched: price }),
      edits,
    );
    const b = usagePriceTableChanges(
      target("b", { example: { ...price, outputCostPerMillionTokens: 10 } }),
      edits,
    );
    expect(a.changes).toEqual([
      {
        model: "example",
        price: { ...price, inputCostPerMillionTokens: 3, cacheReadCostPerMillionTokens: 0 },
      },
    ]);
    expect(b.changes).toEqual([
      { model: "example", price: { inputCostPerMillionTokens: 3, outputCostPerMillionTokens: 10 } },
    ]);
  });

  it("batches new rows and resets, and distinguishes blank cache rates from explicit zero", () => {
    const plan = usagePriceTableChanges(target("a", { example: price }), [
      { ...draft({}), removed: true },
      {
        id: "new:1",
        model: "  vendor/Model  ",
        isNew: true,
        values: {
          inputCostPerMillionTokens: "2",
          outputCostPerMillionTokens: "8",
          cacheReadCostPerMillionTokens: "0",
          cacheWriteCostPerMillionTokens: "",
        },
      },
    ]);
    expect(plan.errors.size).toBe(0);
    expect(plan.changes).toEqual([
      { model: "example", price: null },
      { model: "vendor/Model", price: { ...price, cacheReadCostPerMillionTokens: 0 } },
    ]);
  });

  it("requires complete prices before turning automatic pricing into an override", () => {
    const edits = [draft({ inputCostPerMillionTokens: "3" })];
    expect(usagePriceTableChanges(target("a", { example: price }), edits).errors.size).toBe(0);
    const missing = usagePriceTableChanges(target("b", {}), edits);
    expect(missing.changes).toEqual([]);
    expect(missing.errors.has("model:example")).toBe(true);
  });

  it("ignores empty new rows without blocking other edits", () => {
    const environment = target("a", { example: price });
    const empty: UsagePriceDraft = {
      id: "new:1",
      model: " ",
      isNew: true,
      values: { inputCostPerMillionTokens: " " },
    };
    const plan = usagePriceTableChanges(environment, [
      draft({ inputCostPerMillionTokens: "3" }),
      empty,
    ]);
    expect(plan.errors.size).toBe(0);
    expect(plan.changes).toEqual([
      { model: "example", price: { ...price, inputCostPerMillionTokens: 3 } },
    ]);
    expect(usagePriceTableChanges(environment, [empty]).changes).toEqual([]);
    expect(
      usagePriceTableChanges(environment, [
        { ...empty, values: { inputCostPerMillionTokens: "0" } },
      ]).errors.get(empty.id),
    ).toBe("Enter a model ID.");
  });

  it.each(["Offline", "Read-only access", "Update server to edit prices"])(
    "does not let %s destinations block a valid edit elsewhere",
    (unavailable) => {
      const edits = [draft({ inputCostPerMillionTokens: "3" })];
      const writable = target("writable", { example: price });
      const other = target("other", {});
      expect(usagePriceTableErrors([writable, { ...other, unavailable }], edits).size).toBe(0);
      expect(usagePriceTableErrors([writable, other], edits).has("model:example")).toBe(true);
    },
  );

  it("does not write unchanged rates and rejects invalid edited cells", () => {
    const environment = target("a", { example: price });
    expect(
      usagePriceTableChanges(environment, [draft({ inputCostPerMillionTokens: "2.00" })]).changes,
    ).toEqual([]);
    expect(
      usagePriceTableChanges(environment, [draft({ cacheReadCostPerMillionTokens: "-1" })]).errors
        .size,
    ).toBe(1);
    expect(
      usagePriceTableChanges(environment, [draft({ outputCostPerMillionTokens: "" })]).errors.size,
    ).toBe(1);
  });
});