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

export class HostIdentificationModel implements SchemaModel<HostIdentificationSchema> {
  public email = '';
  public givenName = '';
  public familyName = '';
  public nickname: string | null = null;
  public picture: string | null = null;
  public sub = '';
  public issuerMetadata: IssuerMetadata = {};
  public updatedAt = new Date();

  public constructor(hostIdentificationSchema?: HostIdentificationSchema) {
    if (hostIdentificationSchema) {
      this.fromSchema(hostIdentificationSchema);
    }
  }

  public fromSchema(hostIdentificationSchema: HostIdentificationSchema) {
    this.email = hostIdentificationSchema.email;
    this.givenName = hostIdentificationSchema.given_name;
    this.familyName = hostIdentificationSchema.family_name;
    this.nickname = hostIdentificationSchema.nickname;
    this.picture = hostIdentificationSchema.picture;
    this.sub = hostIdentificationSchema.sub;

    if (hostIdentificationSchema.issuer_metadata) {
      this.issuerMetadata = hostIdentificationSchema.issuer_metadata;
    }

    this.updatedAt = new Date(hostIdentificationSchema.updated_at);
  }

  public toSchema(): HostIdentificationSchema {
    return {
      email: this.email,
      family_name: this.familyName,
      given_name: this.givenName,
      issuer_metadata: this.issuerMetadata,
      nickname: this.nickname,
      picture: this.picture,
      sub: this.sub,
      updated_at: this.updatedAt.toUTCString(),
    };
  }

  public validate() {
    const invalidFields: string[] = [];

    if (!this.email || !this.email.trim().length) {
      invalidFields.push('email');
    }

    if (!this.familyName || !this.familyName.trim().length) {
      invalidFields.push('family_name');
    }

    if (!this.givenName || !this.givenName.trim().length) {
      invalidFields.push('given_name');
    }

    return invalidFields.length ? invalidFields : null;
  }
}

export interface HostIdentificationSchema {
  email: string;
  given_name: string;
  family_name: string;
  nickname: string | null;
  picture: string | null;
  sub: string;
  issuer_metadata: IssuerMetadata;
  updated_at: string;
}

export interface IssuerMetadata {
  webhook_endpoint_join?: string;
  webhook_group?: string;
  webhook_token?: string;
}

export const hostIdentificationValidationSchema: SubSchema = {
  additionalProperties: false,
  description: 'Host Identification Vaildation Schema',
  properties: {
    email: {
      description: 'Host email',
      minLength: 1,
      type: 'string',
    },
    family_name: {
      description: 'Host first name',
      minLength: 1,
      type: 'string',
    },
    given_name: {
      description: 'Host first name',
      minLength: 1,
      type: 'string',
    },
    issuer_metadata: {
      description: 'Metadata from the token issuer for backports and webhooks',
      type: 'object',
    },
    nickname: {
      description: 'Host nickname',
      type: 'string',
    },
    picture: {
      description: 'Host picture url or datauri',
      type: 'string',
    },
    sub: {
      description: 'Host sub',
      minLength: 1,
      type: 'string',
    },
    updated_at: {
      description: 'Updated at timestamp for host identification data',
      type: 'string',
    },
  },
  required: ['email', 'family_name', 'given_name', 'sub'],
  type: 'object',
};