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

import {
  StreamAttendeeModel,
  StreamAttendeeSchema,
  StreamMessageModel,
  StreamMessageSchema,
  StreamSchema,
  StreamServersModel,
  StreamServersSchema,
} from '@verb/src/libs/stream/stream-metadata';
import {
  StreamTransitionStatusModel,
  StreamTransitionStatusSchema,
} from '@verb/src/libs/stream/stream-transition';

export class StreamTransitionStatusResponseModel
  implements BaseModel<StreamTransitionStatusResponseSchema> {
  public attendees?: StreamAttendeeModel[];
  public messages?: StreamMessageModel[];
  public servers?: StreamServersModel;
  public status = new StreamTransitionStatusModel();
  public streamId = 0;
  public streamInstanceId = '';

  public constructor(
    streamSchema: StreamSchema,
    streamTransitionStatusSchema: StreamTransitionStatusSchema,
    streamServersSchema?: StreamServersSchema,
    streamAttendeesSchema?: StreamAttendeeSchema[],
    streamMessagesSchema?: [],
  ) {
    this.fromSchema(
      streamSchema,
      streamTransitionStatusSchema,
      streamServersSchema,
      streamAttendeesSchema,
      streamMessagesSchema,
    );
  }

  public fromSchema(
    streamSchema: StreamSchema,
    streamTransitionStatusSchema: StreamTransitionStatusSchema,
    streamServersSchema?: StreamServersSchema,
    streamAttendeesSchema?: StreamAttendeeSchema[],
    streamMessagesSchema?: StreamMessageSchema[],
  ) {
    this.streamId = streamSchema.stream_id;
    this.streamInstanceId = streamSchema.metadata.stream_instance_id;
    this.status = new StreamTransitionStatusModel(streamTransitionStatusSchema);

    if (streamServersSchema) {
      this.servers = new StreamServersModel(streamServersSchema);
    }

    if (streamAttendeesSchema) {
      this.attendees = streamAttendeesSchema.map(attendee => new StreamAttendeeModel(attendee));
    }

    if (streamMessagesSchema) {
      this.messages = streamMessagesSchema.map(message => new StreamMessageModel(message));
    }
  }

  public toSchema(): StreamTransitionStatusResponseSchema {
    const streamTransitionStatusResponseSchema: StreamTransitionStatusResponseSchema = {
      status: this.status.toSchema(),
      stream_id: this.streamId,
      stream_instance_id: this.streamInstanceId,
    };

    if (this.attendees) {
      streamTransitionStatusResponseSchema.attendees = this.attendees.map(attendee =>
        attendee.toSchema(),
      );
    }

    if (this.messages) {
      streamTransitionStatusResponseSchema.messages = this.messages.map(message =>
        message.toSchema(),
      );
    }

    if (this.servers) {
      streamTransitionStatusResponseSchema.servers = this.servers.toSchema();
    }

    return streamTransitionStatusResponseSchema;
  }
}

export interface StreamTransitionStatusResponseSchema {
  attendees?: StreamAttendeeSchema[];
  messages?: StreamMessageSchema[];
  servers?: StreamServersSchema;
  status: StreamTransitionStatusSchema;
  stream_id: number;
  stream_instance_id: string;
}