import { JSONSchema } from '@squiz/json-schema-library';
import { PrimitiveType, ResolvableType, TypeResolver } from './TypeResolver';

const defaultSchema: JSONSchema = {
  type: 'object',
  properties: {
    myProperty: {
      type: 'string',
    },
  },
  required: ['myProperty'],
};
function primitiveTypeFixture<T extends string>(title: T, schema: JSONSchema = defaultSchema) {
  return PrimitiveType({
    ...schema,
    title,
  });
}

function resolvableTypeFixture<T extends string>(title: T, schema: JSONSchema = defaultSchema) {
  return ResolvableType({
    ...schema,
    title,
  });
}

describe('getValidationSchemaForPrimitive', () => {
  it('should return only the primitive schema when no resolvers are defined', () => {
    const primitiveType = primitiveTypeFixture('MyPrimitive');
    const resolvableType = resolvableTypeFixture('MyResolvable');
    const resolver = new TypeResolver([primitiveType], [resolvableType], {});

    expect(resolver.getValidationSchemaForPrimitive('MyPrimitive')).toEqual([primitiveType]);
  });

  it('should return the primitive schema and the resolvable schema when a resolver is defined', () => {
    const primitiveType = primitiveTypeFixture('MyPrimitive');
    const resolvableType = resolvableTypeFixture('MyResolvable');
    const resolver = new TypeResolver([primitiveType], [resolvableType], {
      MyPrimitive: {
        MyResolvable: () => null,
      },
    });

    expect(resolver.getValidationSchemaForPrimitive('MyPrimitive')).toEqual([primitiveType, resolvableType]);
  });

  it('should return the primitive schema and the resolvable schema when a resolver is defined for a different primitive', () => {
    const primitiveType = primitiveTypeFixture('MyPrimitive');
    const resolvableType = resolvableTypeFixture('MyResolvable');
    const resolver = new TypeResolver([primitiveType, primitiveTypeFixture('MyOtherPrimitive')], [resolvableType], {
      MyOtherPrimitive: {
        MyResolvable: () => null,
      },
    });

    expect(resolver.getValidationSchemaForPrimitive('MyPrimitive')).toEqual([primitiveType]);
  });

  it('should error when resolver map contains a key not listed in resolver schemas', () => {
    const primitiveType = primitiveTypeFixture('MyPrimitive');
    const resolvableType = resolvableTypeFixture('MyResolvable');
    expect(
      () =>
        new TypeResolver<typeof primitiveType, typeof resolvableType>([primitiveType], [resolvableType], {
          MyPrimitive: {
            // @ts-expect-error - this is not a valid resolvable type
            MyOtherResolvable: () => null,
          },
        }),
    ).toThrowError();
  });

  it('should error when resolver map contains a key not listed in primitive schemas', () => {
    const primitiveType = primitiveTypeFixture('MyPrimitive');
    const resolvableType = resolvableTypeFixture('MyResolvable');
    expect(
      () =>
        new TypeResolver<typeof primitiveType, typeof resolvableType>([primitiveType], [resolvableType], {
          // @ts-expect-error - this is not a valid primitive type
          MyOtherPrimitive: {
            MyResolvable: () => null,
          },
        }),
    ).toThrowError();
  });

  it('should return undefined when try to get a resolver for missing primitive', () => {
    const primitiveType = primitiveTypeFixture('MyPrimitive');
    const resolvableType = resolvableTypeFixture('MyResolvable');
    const resolver = new TypeResolver([primitiveType, primitiveTypeFixture('MyOtherPrimitive')], [resolvableType], {
      MyOtherPrimitive: {
        MyResolvable: () => null,
      },
    });

    expect(resolver.tryGetResolver('DoesNotExist', resolvableType)).toEqual(undefined);
  });
});