export enum MessageTypeEnum {
  String = 'string',
  Boolean = 'boolean',
  Numeric = 'numeric',
  List = 'list',
  Map = 'map',
  Object = 'object',
  Raw = 'raw',
  Enum = 'enum',
}

export type StringMessageTextType = 'text' | 'sql';

export interface StringMessage extends MessageConfiguration {
  maxLength?: number;
  textType: StringMessageTextType;
}

export interface BooleanMessage extends MessageConfiguration {}

export interface NumericMessage extends MessageConfiguration {
  min?: number;
  max?: number;
}

export interface ListMessage extends MessageConfiguration {
  subConfiguration: MessageConfiguration;
}

export interface MapMessage extends MessageConfiguration {
  keyConfiguration: MessageConfiguration;
  valueConfiguration: MessageConfiguration;
}

export interface ObjectMessage extends MessageConfiguration {
  messageDefinition: ProtoMessage;
}

export interface RawMessage extends MessageConfiguration {}

export interface EnumMessage extends MessageConfiguration {
  options: string[];
}

export interface MessageConfiguration {
  type: MessageTypeEnum;
}

export const StringMessage = (
  maxLength?: number,
  textType: StringMessageTextType = 'text'
): StringMessage => ({
  type: MessageTypeEnum.String,
  maxLength,
  textType,
});

export const BooleanMessage = (): BooleanMessage => ({
  type: MessageTypeEnum.Boolean,
});

export const NumericMessage = (min?: number, max?: number): NumericMessage => ({
  type: MessageTypeEnum.Numeric,
  min,
  max,
});

export const ListMessage = (
  subConfiguration: MessageConfiguration
): ListMessage => ({
  type: MessageTypeEnum.List,
  subConfiguration,
});

export const MapMessage = (
  keyConfiguration: MessageConfiguration,
  valueConfiguration: MessageConfiguration
): MapMessage => ({
  type: MessageTypeEnum.Map,
  keyConfiguration,
  valueConfiguration,
});

export const ObjectMessage = (messageDefinition: ProtoMessage) => ({
  type: MessageTypeEnum.Object,
  messageDefinition,
});

export const RawMessage = (): RawMessage => ({ type: MessageTypeEnum.Raw });

export const EnumMessage = (options: string[]) => ({
  type: MessageTypeEnum.Enum,
  options,
});

export interface ProtoMessageField<T extends MessageConfiguration> {
  name: string;
  configuration: T;
}

export interface ProtoBase {
  name: string;
  fullName?: string;
  packageName?: string;
}

export interface ProtoMessage extends ProtoBase {
  fileName?: string;
  values: ProtoMessageField<any>[];
}

export interface ProtoEnum extends ProtoBase {
  options: string[];
}

export const UnknownProto = (
  name: string,
  fullName?: string
): ProtoMessage => ({
  name,
  fullName,
  values: [{ name: 'Raw JSON', configuration: RawMessage() }],
});

export const EDITABLE_MESSAGE_TYPES = [
  MessageTypeEnum.String,
  MessageTypeEnum.Numeric,
  MessageTypeEnum.List,
  MessageTypeEnum.Map,
  MessageTypeEnum.Object,
];