/*
 * Copyright (C) 2018 StApps
 * This program is free software: you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the Free
 * Software Foundation, version 3.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License along with
 * this program. If not, see <https://www.gnu.org/licenses/>.
 */
import {
  isLightweightClass,
  isLightweightEnum,
  isUnionType,
} from '@openstapps/core-tools/lib/easy-ast/ast-util';
import {LightweightAliasDefinition} from '@openstapps/core-tools/lib/easy-ast/types/lightweight-alias-definition';
import {LightweightProjectWithIndex} from '@openstapps/core-tools/lib/easy-ast/types/lightweight-project';
import {LightweightType} from '@openstapps/core-tools/lib/easy-ast/types/lightweight-type';
import {LightweightClassDefinition} from '@openstapps/core-tools/src/easy-ast/types/lightweight-class-definition';
import {LightweightDefinition} from '@openstapps/core-tools/src/easy-ast/types/lightweight-definition';
import {LightweightProperty} from '@openstapps/core-tools/src/easy-ast/types/lightweight-property';
import {expect} from 'chai';
import {assign, chain, clone, flatMap, isNil, reduce, reject, some} from 'lodash';

process.on('unhandledRejection', err => {
  throw err;
});

describe('Features', () => {
  let project: LightweightProjectWithIndex;
  let thingNames: string[];
  let things: LightweightClassDefinition[];
  let thingsWithoutReferences: LightweightClassDefinition[];

  before(function () {
    this.timeout(15000);
    this.slow(10000);

    project = new LightweightProjectWithIndex('src');

    const thingsReflection = project.definitions['SCIndexableThings'] as LightweightAliasDefinition;
    expect(isLightweightEnum(thingsReflection)).to.be.true;
    expect(isUnionType(thingsReflection.type!)).to.be.true;

    thingsReflection.type!.specificationTypes!.push({
      flags: 524_288,
      referenceName: 'SCDiff',
    });

    expect(
      thingsReflection.type?.specificationTypes?.every(it => typeof it.referenceName !== 'undefined'),
    ).to.be.true;
    thingNames = thingsReflection.type?.specificationTypes?.map(type => type.referenceName!) ?? [];
    things = thingNames.map(it => project.definitions[it]).filter(isLightweightClass);
    thingsWithoutReferences = thingNames
      .map(it => project.definitions[`${it}WithoutReferences`])
      .filter(isLightweightClass);
  });

  const inheritedProperties = function (
    classLike: LightweightClassDefinition,
  ): Record<string, LightweightProperty> | undefined {
    return reduce(
      [...(classLike.implementedDefinitions ?? []), ...(classLike.extendedDefinitions ?? [])],
      (obj, extension) => {
        const object = project.definitions[extension.referenceName ?? ''];

        return assign(obj, isLightweightClass(object) ? inheritedProperties(object) : obj);
      },
      clone(classLike.properties),
    );
  };

  it('should have an origin', () => {
    for (const thing of things) {
      expect(inheritedProperties(thing)?.['origin']).not.to.be.undefined;
    }
  });

  it('should not have duplicate names', () => {
    reduce(
      project.files,
      (fileResult, file) =>
        reduce(
          file,
          (definitionResult, definition: LightweightDefinition) => {
            expect(definitionResult[definition.name]).to.be.undefined;
            definitionResult[definition.name] = true; // something that's not undefined

            return definitionResult;
          },
          fileResult,
        ),
      {} as Record<string, true>,
    );
  });

  it('should not have properties referencing SCThing', () => {
    const allPropertyReferenceNames: (property: LightweightProperty) => string[] = property =>
      reject(
        [property.type.referenceName!, ...flatMap(property.properties, allPropertyReferenceNames)],
        isNil,
      );

    const typeHasSCThingReferences: (type?: LightweightType) => boolean = type =>
      type?.referenceName
        ? hasSCThingReferences(project.definitions[type.referenceName])
        : some(type?.specificationTypes, typeHasSCThingReferences);

    const hasSCThingReferences: (definition?: LightweightDefinition) => boolean = definition =>
      isLightweightClass(definition)
        ? chain(inheritedProperties(definition))
            .flatMap(it => flatMap(it.properties, allPropertyReferenceNames))
            .map(it => project.definitions[it] as LightweightDefinition)
            .some(it => it.name === 'SCThing' || hasSCThingReferences(it))
            .value()
        : definition
        ? typeHasSCThingReferences(definition.type)
        : false;

    for (const thing of things) {
      expect(hasSCThingReferences(thing)).to.be.false;
    }
  });

  function extendsSCThing(definition?: LightweightDefinition): boolean {
    return isLightweightClass(definition)
      ? chain([
          ...((definition as LightweightClassDefinition).extendedDefinitions ?? []),
          ...((definition as LightweightClassDefinition).implementedDefinitions ?? []),
        ])
          .map(it => it.referenceName)
          .reject(isNil)
          .some(it => it === 'SCThing' || extendsSCThing(project.definitions[it!]))
          .value()
      : false;
  }

  it('should extend SCThing if it is an SCThing', () => {
    for (const thing of things) {
      expect(extendsSCThing(thing)).to.be.true;
    }
  });

  it('should not extend SCThing if it is an SCThingWithoutReferences', () => {
    for (const thingWithoutReferences of thingsWithoutReferences) {
      expect(extendsSCThing(thingWithoutReferences)).to.be.false;
    }
  });
});