import { SchemaModel } from '@verb/src/libs/shared/base/base.model';

import {
  CoreConfigurationMediaTypeModel,
  CoreConfigurationMediaTypeSchema,
  coreConfigurationMediaTypeValidationSchema,
} from './core-configuration-media-type.model';
import {
  CoreConfigurationMediaModel,
  CoreConfigurationMediaSchema,
  coreConfigurationMediaValidationSchema,
} from './core-configuration-media.model';

import { SubSchema } from '@verb/src/libs/shared/json-schema-validator/schema-types';

export class CoreConfigurationModel implements SchemaModel<CoreConfigurationSchema> {
  public editorConfiguration = {};
  // TODO: create separate CoreConfigurationMediaConfigurationModel with these two properties
  public media: CoreConfigurationMediaModel[] = [];
  public mediaTypes: CoreConfigurationMediaTypeModel[] = [];

  public constructor(schema?: CoreConfigurationSchema) {
    if (schema) {
      this.fromSchema(schema);
    }
  }

  public fromSchema(schema: CoreConfigurationSchema) {
    // tslint:disable-next-line: no-unsafe-any
    this.editorConfiguration = schema.editor_configuration;
    // TODO: create a separate CoreConfigurationMediaConfigurationModel
    // this.mediaConfiguration =
    //   new CoreConfigurationMediaConfigurationModel(schema.media_configuration);
    this.media = schema.media_configuration?.media?.map(
      media => new CoreConfigurationMediaModel(media),
    );
    this.mediaTypes = schema.media_configuration?.media_types?.map(
      mediaType => new CoreConfigurationMediaTypeModel(mediaType),
    );
  }

  public toSchema(): CoreConfigurationSchema {
    return {
      editor_configuration: this.editorConfiguration,
      // TODO: delegate to CoreConfigurationMediaConfigurationModel
      // media_configuration: this.mediaConfiguration.toSchema()
      media_configuration: {
        media: this.media?.map(media => media.toSchema()),
        media_types: this.mediaTypes?.map(mediaType => mediaType.toSchema()),
      },
    };
  }
}

export interface CoreConfigurationSchema {
  // tslint:disable-next-line: no-any
  editor_configuration: any;
  media_configuration: {
    media: CoreConfigurationMediaSchema[];
    media_types: CoreConfigurationMediaTypeSchema[];
  };
}

export const coreConfigurationValidationSchema: SubSchema = {
  additionalProperties: true,
  description: 'Core Configuration Validation Schema',
  properties: {
    editor_configuration: {
      additionalProperties: true,
      description: 'Core editor configuration',
    },
    media_configuration: {
      additionalProperties: false,
      description: 'Core media configuration',
      properties: {
        media: {
          description: 'Media configuration',
          items: coreConfigurationMediaValidationSchema,
          type: 'array',
        },
        media_types: {
          description: 'Media types configuration',
          items: coreConfigurationMediaTypeValidationSchema,
          type: 'array',
        },
      },
      required: ['media', 'media_types'],
      type: 'object',
    },
  },
  required: ['editor_configuration', 'media_configuration'],
  type: 'object',
};