import { TestBed } from '@angular/core/testing';

import { provideExperimentalZonelessChangeDetection } from '@angular/core';
import {
  EnumMessage,
  ListMessage,
  MapMessage,
  MessageTypeEnum,
  ObjectMessage,
  ProtoMessage,
} from './model/proto-message.model';
import { ProtoDefinitionService } from './proto-definition.service';

let testProto = `
syntax="proto3";

message Test {
  message NestedMessage {
    string nested = 1;
  }
  string hello = 1;
  int32 hello2 = 2;
  int64 hello3 = 3;
  float hello4 = 4;
  double hello5 = 5;
  bool hello6 = 6;
  repeated string hello7 = 7;
  map<string, string> hello8 = 8;
  ReferenceMessage hello9 = 9;
  NestedMessage hello10 = 10;
  EnumTest enum_test = 11;
}

message ReferenceMessage {
  string test = 1; 
}

enum EnumTest {
  Hello = 0;
}

`;

describe('TestService', () => {
  let service: ProtoDefinitionService;

  beforeEach(() => {
    TestBed.configureTestingModule({
      providers: [provideExperimentalZonelessChangeDetection()],
    });
    service = TestBed.inject(ProtoDefinitionService);
  });

  it('should convert parse protobuf correctly', async () => {
    const testMessages = await service.parseProtoDefinition(testProto);
    const converted = testMessages[1];

    expect(converted.name).toBe('Test');

    expect(converted.values.length).toBe(11);
    checkNameAndType(converted, 'hello', MessageTypeEnum.String);
    checkNameAndType(converted, 'hello2', MessageTypeEnum.Numeric);
    checkNameAndType(converted, 'hello3', MessageTypeEnum.Numeric);
    checkNameAndType(converted, 'hello4', MessageTypeEnum.Numeric);
    checkNameAndType(converted, 'hello5', MessageTypeEnum.Numeric);
    checkNameAndType(converted, 'hello6', MessageTypeEnum.Boolean);
    checkNameAndType(converted, 'hello7', MessageTypeEnum.List);
    checkNameAndType(converted, 'hello8', MessageTypeEnum.Map);
    checkNameAndType(converted, 'hello9', MessageTypeEnum.Object);
    checkNameAndType(converted, 'hello10', MessageTypeEnum.Object);
    checkNameAndType(converted, 'enumTest', MessageTypeEnum.Enum);

    const listMessage = converted.values[6].configuration as ListMessage;
    expect(listMessage.subConfiguration.type).toBe(MessageTypeEnum.String);

    const mapMessage = converted.values[7].configuration as MapMessage;
    expect(mapMessage.keyConfiguration.type).toBe(MessageTypeEnum.String);
    expect(mapMessage.valueConfiguration.type).toBe(MessageTypeEnum.String);

    const referenceMessage = converted.values[8].configuration as ObjectMessage;
    expect(referenceMessage.messageDefinition.values.length).toBe(1);
    expect(referenceMessage.messageDefinition.name).toBe('ReferenceMessage');
    const nestedReferenceMessage = referenceMessage.messageDefinition.values[0];
    expect(nestedReferenceMessage.configuration.type).toBe(
      MessageTypeEnum.String
    );
    expect(nestedReferenceMessage.name).toBe('test');

    const nestedMessage = converted.values[9].configuration as ObjectMessage;
    expect(nestedMessage.messageDefinition.values.length).toBe(1);
    expect(nestedMessage.messageDefinition.name).toBe('NestedMessage');
    const nestedNestedMessage = nestedMessage.messageDefinition.values[0];
    expect(nestedNestedMessage.configuration.type).toBe(MessageTypeEnum.String);
    expect(nestedNestedMessage.name).toBe('nested');

    const enumMessage = converted.values[10].configuration as EnumMessage;
    expect(enumMessage.options.length).toBe(1);
    expect(enumMessage.options[0]).toBe('Hello');
  });
});

const checkNameAndType = (
  converted: ProtoMessage,
  name: string,
  type: MessageTypeEnum
) => {
  const field = converted.values.find((value) => value.name === name);
  expect(field?.configuration.type).toBe(type);
};