import { HonorlockElementsElement } from './HonorlockElementsElement.js';
import { DefaultConfiguration } from './Entities/DefaultConfiguration.js';
import { ConfigurationInterface } from './Entities/ConfigurationInterface.js';
import { DimensionInterface } from './Entities/DimensionInterface.js';
import { Config } from './Config.js';
import { ValidationResponseInterface } from './Entities/ValidationResponseInterface.js';
import { Validator } from './Validator.js';

export class HonorlockElements {
  private _configs: Config[] = [new Config(DefaultConfiguration)];

  private _validation: ValidationResponseInterface = new Validator(
    this._configs[0].config
  ).getValidation();

  init = (configuration: ConfigurationInterface) => {
    this.validate(configuration);
    this.configure(configuration);

    if (!window.customElements.get('honorlock-elements')) {
      window.customElements.define(
        'honorlock-elements',
        HonorlockElementsElement
      );
    }
  };

  private configure(configuration: ConfigurationInterface): void {
    this._configs.push(new Config(configuration));

    // Remove dupes
    this._configs = Array.from(
      new Map(this._configs.map(item => [item.config.key, item])).values()
    );
  }

  private validate(configuration: ConfigurationInterface): void {
    this._validation = new Validator(configuration).getValidation();
  }

  public getConfigurations(): Config[] {
    return this._configs;
  }

  public getValidation(): ValidationResponseInterface {
    return this._validation;
  }

  resize = (configuration: DimensionInterface) => {
    this._configs.forEach((config, idx) => {
      const resizeValidation: Config = new Config(config.config);

      if ('height' in configuration) {
        resizeValidation.config.height = configuration.height;
      }
      if ('width' in configuration) {
        resizeValidation.config.width = configuration.width;
      }

      const resizeValidator = new Validator(
        resizeValidation.config
      ).getValidation();

      if (resizeValidator.errors.length > 0) {
        resizeValidator.errors.forEach((item: string) => {
          // eslint-disable-next-line no-console
          console.error(item);
        });
      } else {
        this._configs[idx].config.height = resizeValidation.config.height;
        this._configs[idx].config.width = resizeValidation.config.width;

        const honorlockiFrame = document
          .querySelector('honorlock-elements')
          ?.shadowRoot?.getElementById('honorlock-frame');
        if (honorlockiFrame) {
          honorlockiFrame.setAttribute(
            'height',
            this._configs[idx].config.height.toString()
          );
          honorlockiFrame.setAttribute(
            'width',
            this._configs[idx].config.width.toString()
          );
        }
      }
    });
  };
}

window.HonorlockElements = new HonorlockElements();

declare global {
  interface Window {
    HonorlockElements: any;
  }
}