import { SchemaModel } from '@verb/src/libs/shared/base/base.model';
import { SubSchema } from '@verb/src/libs/shared/json-schema-validator/schema-types';
import {
  StreamConfigurationModel,
  StreamConfigurationSchema,
  streamConfigurationValidationSchema,
} from '@verb/src/libs/stream/host-metadata';
import {
  StreamAttendeeModel,
  StreamAttendeeSchema,
  streamAttendeeValidationSchema,
} from './stream-attendee.model';
import { StreamFlagsModel, StreamFlagsSchema } from './stream-flags.model';
import {
  StreamMessageModel,
  StreamMessageSchema,
  streamMessageValidationSchema,
} from './stream-message.model';
import {
  StreamMetricsModel,
  StreamMetricsSchema,
  streamMetricsValidationSchema,
} from './stream-metrics.model';
import {
  StreamRecordingModel,
  StreamRecordingSchema,
  streamRecordingValidationSchema,
} from './stream-recording.model';
import {
  StreamServersModel,
  StreamServersSchema,
  streamServerValidationSchema,
} from './stream-servers.model';

export class StreamMetadataModel implements SchemaModel<StreamMetadataSchema> {
  public attendees: StreamAttendeeModel[] = [];
  public configuration = new StreamConfigurationModel();
  public flags = new StreamFlagsModel();
  public messages: StreamMessageModel[] = [];
  public metrics = new StreamMetricsModel();
  public recordings: StreamRecordingModel[] = [];
  public servers: StreamServersModel | null = null;
  public streamInstanceId = '';

  public constructor(streamMetadataSchema?: StreamMetadataSchema) {
    if (streamMetadataSchema) {
      this.fromSchema(streamMetadataSchema);
    }
  }

  public fromSchema(streamMetadataSchema: StreamMetadataSchema): void {
    this.attendees = streamMetadataSchema.attendees.map(
      attendee => new StreamAttendeeModel(attendee),
    );
    this.configuration = new StreamConfigurationModel(streamMetadataSchema.configuration);
    this.flags = new StreamFlagsModel(streamMetadataSchema.flags);
    this.messages = streamMetadataSchema.messages.map(message => new StreamMessageModel(message));
    this.metrics = new StreamMetricsModel(streamMetadataSchema.metrics);
    this.recordings = streamMetadataSchema.recordings.map(
      recording => new StreamRecordingModel(recording),
    );
    this.servers = streamMetadataSchema.servers
      ? new StreamServersModel(streamMetadataSchema.servers)
      : null;
    this.streamInstanceId = streamMetadataSchema.stream_instance_id;
  }

  public toSchema(): StreamMetadataSchema {
    return {
      attendees: this.attendees.map(streamAttendeeModel => streamAttendeeModel.toSchema()),
      configuration: this.configuration.toSchema(),
      flags: this.flags.toSchema(),
      messages: this.messages.map(messageModel => messageModel.toSchema()),
      metrics: this.metrics.toSchema(),
      recordings: this.recordings.map(recordingModel => recordingModel.toSchema()),
      servers: this.servers ? this.servers.toSchema() : null,
      stream_instance_id: this.streamInstanceId,
    };
  }
}

export interface StreamMetadataSchema {
  attendees: StreamAttendeeSchema[];
  configuration: StreamConfigurationSchema;
  flags: StreamFlagsSchema;
  messages: StreamMessageSchema[];
  metrics: StreamMetricsSchema;
  recordings: StreamRecordingSchema[];
  servers: StreamServersSchema | null;
  stream_instance_id: string;
}

export const streamMetadataValidationSchema: SubSchema = {
  additionalProperties: false,
  description: 'Stream Metadata Validation Schema',
  properties: {
    attendees: {
      description: 'Attendees',
      items: streamAttendeeValidationSchema,
      type: 'array',
    },
    configuration: streamConfigurationValidationSchema,
    messages: {
      description: 'Messages',
      items: streamMessageValidationSchema,
      type: 'array',
    },
    metrics: streamMetricsValidationSchema,
    recordings: {
      description: 'Recordings',
      items: streamRecordingValidationSchema,
      type: 'array',
    },
    servers: streamServerValidationSchema,
    stream_instance_id: {
      description: 'Stream instance ID',
      minLength: 1,
      type: 'string',
    },
  },
  required: [
    'attendees',
    'configuration',
    'messages',
    'metrics',
    'recordings',
    'servers',
    'stream_instance_id',
  ],
  type: 'object',
};