import { GenerateTypescriptOptions } from './types';
import { versionMajorMinor as TSVersion } from 'typescript';
import {
  isBuiltinType,
  descriptionToJSDoc,
  createFieldRef,
  pascalCase,
} from './utils';
import {
  IntrospectionType,
  IntrospectionScalarType,
  IntrospectionEnumType,
  IntrospectionObjectType,
  IntrospectionUnionType,
  IntrospectionInputObjectType,
  IntrospectionInterfaceType,
  IntrospectionQuery,
  IntrospectionField,
  IntrospectionInputValue,
} from 'graphql';

export class TypeScriptGenerator {
  constructor(
    protected options: GenerateTypescriptOptions,
    protected introspectResult: IntrospectionQuery,
    protected outputPath: string
  ) {}

  public async generate(): Promise<string[]> {
    const { introspectResult } = this;
    const gqlTypes = introspectResult.__schema.types.filter(
      (type) => !isBuiltinType(type)
    );

    return gqlTypes.reduce<string[]>((prevTypescriptDefs, gqlType) => {
      const jsDoc = descriptionToJSDoc({ description: gqlType.description });
      let typeScriptDefs: string[] = [].concat(jsDoc);

      switch (gqlType.kind) {
        case 'SCALAR': {
          typeScriptDefs = typeScriptDefs.concat(
            this.generateCustomScalarType(gqlType)
          );
          break;
        }

        case 'ENUM': {
          typeScriptDefs = typeScriptDefs.concat(
            this.generateEnumType(gqlType)
          );
          break;
        }

        case 'OBJECT':
        case 'INPUT_OBJECT':
        case 'INTERFACE': {
          typeScriptDefs = typeScriptDefs.concat(
            this.generateObjectType(gqlType, gqlTypes)
          );
          break;
        }

        case 'UNION': {
          typeScriptDefs = typeScriptDefs.concat(
            this.generateUnionType(gqlType)
          );
          break;
        }

        default: {
          throw new Error(`Unknown type kind ${(gqlType as any).kind}`);
        }
      }

      typeScriptDefs.push('');

      return prevTypescriptDefs.concat(typeScriptDefs);
    },                               []);
  }

  private generateCustomScalarType(
    scalarType: IntrospectionScalarType
  ): string[] {
    const customScalarType = this.options.customScalarType || {};
    if (customScalarType[scalarType.name]) {
      return [
        `export type ${this.options.typePrefix}${scalarType.name} = ${
          customScalarType[scalarType.name]
        };`,
      ];
    }

    return [`export type ${this.options.typePrefix}${scalarType.name} = any;`];
  }

  private isStringEnumSupported(): boolean {
    const [major, minor] = TSVersion.split('.').map((v) => +v);
    return (major === 2 && minor >= 5) || major > 2;
  }

  private generateEnumType(enumType: IntrospectionEnumType): string[] {
    // if using old typescript, which doesn't support string enum: convert enum to string union
    if (!this.isStringEnumSupported() || this.options.noStringEnum) {
      return this.createUnionType(
        enumType.name,
        enumType.enumValues.map((v) => `'${v.name}'`)
      );
    }

    let enumBody = enumType.enumValues.reduce<string[]>(
      (prevTypescriptDefs, enumValue, index) => {
        let typescriptDefs: string[] = [];
        const enumValueJsDoc = descriptionToJSDoc(enumValue);

        const isLastEnum = index === enumType.enumValues.length - 1;
        const graphQlEnumValueName = enumValue.name;
        const typescriptEnumValueName = this.generateEnumValueName(
          graphQlEnumValueName
        );

        if (!isLastEnum) {
          typescriptDefs = [
            ...enumValueJsDoc,
            `${typescriptEnumValueName} = '${graphQlEnumValueName}',`,
          ];
        } else {
          typescriptDefs = [
            ...enumValueJsDoc,
            `${typescriptEnumValueName} = '${graphQlEnumValueName}'`,
          ];
        }

        if (enumValueJsDoc.length > 0) {
          typescriptDefs = ['', ...typescriptDefs];
        }

        return prevTypescriptDefs.concat(typescriptDefs);
      },
      []
    );

    // if code is generated as type declaration, better use export const enum instead
    // of just export enum
    const isGeneratingDeclaration =
      this.options.global ||
      !!this.options.namespace ||
      this.outputPath.endsWith('.d.ts');
    const enumModifier = isGeneratingDeclaration ? ' const ' : ' ';
    return [
      `export${enumModifier}enum ${this.options.typePrefix}${enumType.name} {`,
      ...enumBody,
      '}',
    ];
  }

  private generateEnumValueName(graphQlName: string): string {
    if (this.options.enumsAsPascalCase) {
      return pascalCase(graphQlName);
    } else {
      return graphQlName;
    }
  }

  private generateObjectType(
    objectType:
      | IntrospectionObjectType
      | IntrospectionInputObjectType
      | IntrospectionInterfaceType,
    allGQLTypes: IntrospectionType[]
  ): string[] {
    const fields: readonly (IntrospectionInputValue | IntrospectionField)[] =
      objectType.kind === 'INPUT_OBJECT'
        ? objectType.inputFields
        : objectType.fields;

    const extendTypes: string[] =
      objectType.kind === 'OBJECT'
        ? objectType.interfaces.map((i) => i.name)
        : [];

    const extendGqlTypes = allGQLTypes.filter(
      (t) => extendTypes.indexOf(t.name) !== -1
    ) as IntrospectionInterfaceType[];
    const extendFields = extendGqlTypes.reduce<string[]>(
      (prevFieldNames, gqlType) => {
        return prevFieldNames.concat(gqlType.fields.map((f) => f.name));
      },
      []
    );

    const objectFields = fields.reduce<string[]>(
      (prevTypescriptDefs, field, index) => {
        if (
          extendFields.indexOf(field.name) !== -1 &&
          this.options.minimizeInterfaceImplementation
        ) {
          return prevTypescriptDefs;
        }

        const fieldJsDoc = descriptionToJSDoc(field);
        const { fieldName, fieldType } = createFieldRef(
          field,
          this.options.typePrefix,
          this.options.strictNulls
        );
        const fieldNameAndType = `${fieldName}: ${fieldType};`;
        let typescriptDefs = [...fieldJsDoc, fieldNameAndType];

        if (fieldJsDoc.length > 0) {
          typescriptDefs = ['', ...typescriptDefs];
        }

        return prevTypescriptDefs.concat(typescriptDefs);
      },
      []
    );

    const possibleTypeNames: string[] = [];
    const possibleTypeNamesMap: string[] = [];
    if (objectType.kind === 'INTERFACE') {
      possibleTypeNames.push(
        ...[
          '',
          `/** Use this to resolve interface type ${objectType.name} */`,
          ...this.createUnionType(
            `Possible${objectType.name}TypeNames`,
            objectType.possibleTypes.map((pt) => `'${pt.name}'`)
          ),
        ]
      );

      possibleTypeNamesMap.push(
        ...[
          '',
          `export interface ${this.options.typePrefix}${objectType.name}NameMap {`,
          `${objectType.name}: ${this.options.typePrefix}${objectType.name};`,
          ...objectType.possibleTypes.map((pt) => {
            return `${pt.name}: ${this.options.typePrefix}${pt.name};`;
          }),
          '}',
        ]
      );
    }

    const extendStr =
      extendTypes.length === 0
        ? ''
        : `extends ${extendTypes
            .map((t) => this.options.typePrefix + t)
            .join(', ')} `;
    return [
      `export interface ${this.options.typePrefix}${objectType.name} ${extendStr}{`,
      ...objectFields,
      '}',
      ...possibleTypeNames,
      ...possibleTypeNamesMap,
    ];
  }

  private generateUnionType(unionType: IntrospectionUnionType): string[] {
    const { typePrefix } = this.options;
    const possibleTypesNames = [
      '',
      `/** Use this to resolve union type ${unionType.name} */`,
      ...this.createUnionType(
        `Possible${unionType.name}TypeNames`,
        unionType.possibleTypes.map((pt) => `'${pt.name}'`)
      ),
    ];
    const possibleTypeNamesMap = [
      '',
      `export interface ${this.options.typePrefix}${unionType.name}NameMap {`,
      `${unionType.name}: ${this.options.typePrefix}${unionType.name};`,
      ...unionType.possibleTypes.map((pt) => {
        return `${pt.name}: ${this.options.typePrefix}${pt.name};`;
      }),
      '}',
    ];

    const unionTypeTSDefs = this.createUnionType(
      unionType.name,
      unionType.possibleTypes.map((type) => {
        if (isBuiltinType(type)) {
          return type.name;
        } else {
          return typePrefix + type.name;
        }
      })
    );

    return [...unionTypeTSDefs, ...possibleTypesNames, ...possibleTypeNamesMap];
  }

  /**
   * Create a union type e.g: type Color = 'Red' | 'Green' | 'Blue' | ...
   * Also, if the type is too long to fit in one line, split them info multiple lines
   * => type Color = 'Red'
   *      | 'Green'
   *      | 'Blue'
   *      | ...
   */
  private createUnionType(typeName: string, possibleTypes: string[]): string[] {
    const result = `export type ${
      this.options.typePrefix
    }${typeName} = ${possibleTypes.join(' | ')};`;
    if (result.length <= 80) {
      return [result];
    }

    const [firstLine, rest] = result.split('=');

    return [
      firstLine + '=',
      ...rest
        .replace(/ \| /g, ' |\n')
        .split('\n')
        .map((line) => line.trim()),
    ];
  }
}