// tslint:disable: max-classes-per-file
import { BaseModel } from '@verb/src/libs/shared/base/base.model';
import {
  CoreConfigurationModel,
  CoreConfigurationSchema,
  HostSchema,
} from '@verb/src/libs/stream/host-metadata';

import {
  StreamAttendeeModel,
  StreamAttendeeSchema,
  StreamFlagsModel,
  StreamFlagsSchema,
  StreamMetricsModel,
  StreamMetricsSchema,
} from '@verb/src/libs/stream/stream-metadata';
import { StreamStatusSchema } from '@verb/src/libs/stream/stream-status';

export class StreamStatusResponseModel implements BaseModel<StreamStatusResponseSchema> {
  public attendees: StreamAttendeeModel[] = [];
  public coreConfiguration = new CoreConfigurationModel();
  public flags = new StreamFlagsModel();
  public metrics = new StreamMetricsModel();
  public retrievedAt = new Date();
  public streamId = 0;
  public streamInstanceId = '';
  public timeRemainingInSeconds: number | null = null;

  public constructor(streamStatusSchema?: StreamStatusSchema, hostSchema?: HostSchema) {
    if (streamStatusSchema) {
      this.fromSchema(streamStatusSchema, hostSchema);
    }
  }

  public fromSchema(streamStatusSchema: StreamStatusSchema, hostSchema?: HostSchema) {
    const { MAXIMUM_TIME_PER_STREAM_IN_SECONDS: timeRemainingInSecondsGlobal } = process.env;

    this.attendees = streamStatusSchema.stream.metadata.attendees.map(
      attendee => new StreamAttendeeModel(attendee),
    );
    this.coreConfiguration = new CoreConfigurationModel(hostSchema?.core_configuration);
    this.flags = new StreamFlagsModel(streamStatusSchema.stream.metadata.flags);
    this.metrics = new StreamMetricsModel(streamStatusSchema.stream.metadata.metrics);
    this.retrievedAt = new Date(streamStatusSchema.retrieved_at);
    this.streamId = streamStatusSchema.stream.stream_id;
    this.streamInstanceId = streamStatusSchema.stream.stream_instance_id;
    this.timeRemainingInSeconds = Math.min(
      +timeRemainingInSecondsGlobal,
      streamStatusSchema.time_remaining_in_seconds !== null
        ? streamStatusSchema.time_remaining_in_seconds
        : 0,
    );
  }

  public toSchema(): StreamStatusResponseSchema {
    return {
      attendees: this.attendees.map(attendee => attendee.toSchema()),
      core_configuration: this.coreConfiguration.toSchema(),
      flags: this.flags.toSchema(),
      metrics: this.metrics.toSchema(),
      retrieved_at: this.retrievedAt.toUTCString(),
      stream_id: this.streamId,
      stream_instance_id: this.streamInstanceId,
      time_remaining_in_seconds: this.timeRemainingInSeconds,
    };
  }
}

export interface StreamStatusResponseSchema {
  attendees: StreamAttendeeSchema[];
  core_configuration: CoreConfigurationSchema;
  flags: StreamFlagsSchema;
  metrics: StreamMetricsSchema;
  retrieved_at: string;
  stream_id: number;
  stream_instance_id: string;
  time_remaining_in_seconds: number | null;
}