import type { TypeEqual, TypeOf } from "ts-expect";
import { expectType } from "ts-expect";
import { it } from "vitest";

import type {
  ConstructorOptions,
  UnusedCesiumProps,
  PickCesiumProps,
  Merge,
  UnionMerge,
  ArrayKeys,
} from "./types";

class Test {
  constructor({ hoge }: { hoge: string }) {
    this.hoge = hoge;
  }
  hoge: string | null;
  readonly foo = true;
  bar() {
    return 1;
  }
}

// Test class for optional properties (similar to Cesium 1.135.0 changes)
class TestWithOptional {
  requiredProp = "test";
  optionalProp: number | undefined;
  readonly readOnlyProp = true;
  method() {
    return 1;
  }
}

// Test class for private properties (starting with underscore)
class TestWithPrivate {
  publicProp = "public";
  _privateProp = 42;
  readonly readOnlyProp = true;
  method() {
    return 1;
  }
}

type TestOptions = {
  hoge?: string | number;
};

const keys = ["hoge", "foo", "bar"] as const;
const readOnlyKeys: string[] = ["hoge", "foo", "bar"];
// Suppress unused vars - these are used for type testing
void keys;
void readOnlyKeys;

expectType<TypeEqual<ArrayKeys<[1, 2] | 1 | ["hoge"] | "foo" | undefined | null>, "hoge" | "foo">>(
  true,
);
expectType<
  TypeOf<
    Merge<{ a: string; b?: string }, { b: number; c?: boolean }>,
    { a: string; b: number; c?: boolean }
  >
>(true);
expectType<
  TypeOf<
    UnionMerge<{ a: string; b?: string }, { b: number; c?: boolean }>,
    { a: string; b: string | number | undefined; c?: boolean }
  >
>(true);
expectType<TypeEqual<ConstructorOptions<typeof Test>, { hoge: string }>>(true);
expectType<TypeEqual<UnusedCesiumProps<Test, { hoge: boolean }>, never>>(true);
expectType<TypeEqual<UnusedCesiumProps<Test, {}>, "hoge">>(true);
expectType<TypeEqual<UnusedCesiumProps<Test, { foo: boolean }>, "hoge" | "foo">>(true);
expectType<TypeEqual<UnusedCesiumProps<Test, { hoge: boolean; foo: string }>, "foo">>(true);
expectType<TypeEqual<UnusedCesiumProps<Test, { hoge: boolean }, {}, "foo">, never>>(true);
expectType<TypeOf<PickCesiumProps<Test, "hoge" | "foo" | "bar">, { hoge?: string | null }>>(true);
expectType<TypeOf<PickCesiumProps<Test, typeof keys>, { hoge?: string | null }>>(true);
expectType<TypeOf<PickCesiumProps<Test, typeof readOnlyKeys>, { hoge?: string | number }>>(true);
expectType<TypeOf<PickCesiumProps<Merge<Test, TestOptions>, "hoge">, { hoge?: string | number }>>(
  true,
);
expectType<
  TypeOf<PickCesiumProps<UnionMerge<Test, TestOptions>, "hoge">, { hoge?: string | number | null }>
>(true);

// Test UnusedCesiumProps with optional properties
expectType<
  TypeEqual<UnusedCesiumProps<TestWithOptional, { requiredProp: string; optionalProp: number }>, never>
>(true);
expectType<
  TypeEqual<UnusedCesiumProps<TestWithOptional, { requiredProp: string }>, "optionalProp">
>(true);

// Test UnusedCesiumProps with private properties (should be automatically filtered)
expectType<
  TypeEqual<UnusedCesiumProps<TestWithPrivate, { publicProp: string }>, never>
>(true);
expectType<
  TypeEqual<UnusedCesiumProps<TestWithPrivate, {}>, "publicProp">
>(true);
// _privateProp should NOT appear as unused since it's filtered by PrivateKeys

it("should be compiled", () => {});