/**
 * @mergeTarget
 * @module Src/Screens
 */
import {
  LisioBooleanParameterNames,
  LisioCategory,
  LisioNumericParameter,
  LisioNumericParameterNames,
  LisioParameter,
  LisioParameterNames,
  LisioProfileNames,
  LisioStringParameter,
  LisioStringParameterNames,
} from "@lisio/lisio-profils";
import { CategoryComponent } from "../components/category/category-component";
import { CheckboxButton } from "../components/checkbox-button/checkbox-button";
import { CustomChoice } from "../components/inputs/choice/custom-choice";
// import { CustomSlider } from "../components/inputs/slider/custom-slider";
import { CustomTextInput } from "../components/inputs/text/custom-text-input";
import { ElementsContainer } from "../components/containers/elements-container/elements-container";
import { CustomText } from "../components/custom-text/custom-text";
import {
  BooleanParameterRenderObject,
  StringParameterRenderObject,
  NumberParameterRenderObject,
  ComponentAndPosition,
  CategoryRenderObject,
  ProfileRenderObject,
  MergedCategoriesNames,
  VisualCategoryNames,
  ScreenNames,
} from "./screen-types";
import { LisioComponent } from "@lisio/lisio-engine";
import { CustomButton } from "../components/custom-button/custom-button";
import { CustomIcon } from "../components/custom-icon/custom-icon";
import { ScreenManager } from "../../managers/screen-manager";
import { ListContainer } from "../components/containers/list-container/list-container";
import { TextsContainer } from "../components/containers/texts-container/texts-container";
import { CustomLink } from "../components/custom-link/custom-link";
import { UserController } from "../../controllers/user-controller";
import { BackButton } from "../components/back-button/back-button";
import { InputManager } from "../../managers/input-manager";
import { CustomRange } from "../components/inputs/range/custom-range";

/**
 * ## How to create a new screen ?
 *
 * To create a new screen you first need to identify if :
 *  * This screen represents a category from package : check if your category exists in package else add it
 *  * This screen is specific to widget : check if your category exists in {@link Src/Screens.VisualCategoryNames | VisualCategoryNames} else add it
 * Then create a new screen extending LisioScreen.\
 * In constructor of your new screen design your screen as a component. If you need to create categories, profiles or parameters don't forget to call utility methods provided by abstract calss.\
 * Next add a method in {@link Src/Versions.WidgetVersion | WidgetVersion} to create and add your new screen
 * If you need to add this screen in navigation see {@link Src/Components/CustomNav.CustomNav | CustomNav}
 *
 * ## How to modify a screen ?
 *
 * Modify constructor of your screen.\
 *
 * ## How to delete a screen ?
 *
 * To delete a screen you first need to identify if :
 *  * This screen represents a category from package : check if your category exists in package then remove it
 *  * This screen is specific to widget : check if your category exists in {@link Src/Screens.VisualCategoryNames | VisualCategoryNames} then remove it
 * Then delete the screen class.\
 * Next remove the method in {@link Src/Versions.WidgetVersion | WidgetVersion} corresponding to deleted screen.
 * If you need to delete this screen in navigation see {@link Src/Components/CustomNav.CustomNav | CustomNav}
 *
 * ## How to add a category, profile or parameter in screen ?
 *
 * It's very simple, to begin find screen representing the category which use your category, profile or parameter.\
 * Add a render objects in corresponding attribute of the screen class.\
 *
 * ## Documentation
 *
 * Abstract class representing a screen component extending LisioComponent.\
 * It aims to represent a screen component.\
 * A screen component is basically a component to defines the concept of screen.\
 * To execute his responsability this class provides :
 *  * Methods to create all UI categories of a screen
 *  * Methods to create all UI profiles of a screen
 *  * Methods to create all UI parameters of a screen
 *  * Method to create title, subtitle and footer of a screen
 */
abstract class LisioScreen extends LisioComponent {
  /**
   * Protected attribute to store screen title
   * @source
   */
  protected _screenTitle?: CustomText;

  /**
   * Private attriubute to store the screen's back button
   * @source
   */
  private _backButton?: BackButton;

  /**
   * setter for the {@link _backButton | _backButton} attribute
   * @source
   */
  public set backButton(backButton: BackButton) {
    this._backButton = backButton;
  }

  /**
   * getter for the {@link _backButton | _backButton} attribute
   * @source
   */
  public get backButton(): BackButton | undefined {
    return this._backButton;
  }

  /**
   * Protected abstract attribute to store category render objects
   * @source
   */
  protected abstract _categoryRenderObjects: Map<
    MergedCategoriesNames,
    CategoryRenderObject
  >;
  /**
   * Protected abstract attribute to store profile render objects
   * @source
   */
  protected abstract _profileRenderObjects: Map<
    LisioProfileNames,
    ProfileRenderObject
  >;

  /**
   * Protected abstract attribute to store parameter render objects
   * @source
   */
  protected abstract _parameterRenderObjects: Map<
    LisioParameterNames,
    | BooleanParameterRenderObject
    | StringParameterRenderObject
    | NumberParameterRenderObject
  >;

  /**
   * Protected attribute to indicates if has to load assets when rendered
   * @source
   */
  protected _hasToLoadAssets: boolean = false;

  /**
   * Protected attribute to store category related to this screen
   * @source
   */
  protected _categoryName?: MergedCategoriesNames;

  /**
   * Protected attribute to store parent screen name in screen tree
   * @source
   */
  protected _parentScreenName?: string;

  /**
   * Getter for attribute {@link _screenTitle | _screenTitle}
   * @returns Returns _screenTitle attribute
   * @source
   */
  public get screenTitle(): CustomText | undefined {
    return this._screenTitle;
  }

  /**
   * Getter for attribute {@link _categoryRenderObjects | _categoryRenderObjects}
   * @returns Returns _categoryRenderObjects attribute
   * @source
   */
  public get categoryRenderObjects(): Map<
    MergedCategoriesNames,
    CategoryRenderObject
  > {
    return this._categoryRenderObjects;
  }

  /**
   * Getter for attribute {@link _hasToLoadAssets | _hasToLoadAssets}
   * @returns Returns _hasToLoadAssets attribute
   * @source
   */
  public get hasToLoadAssets(): boolean {
    return this._hasToLoadAssets;
  }

  /**
   * Getter for attribute {@link _categoryName | _categoryName}
   * @returns Returns _categoryName attribute
   * @source
   */
  public get categoryName(): MergedCategoriesNames | undefined {
    return this._categoryName;
  }

  /**
   * Getter for attribute {@link _parentScreenName | _parentScreenName}
   * @returns Returns _parentScreenName attribute
   * @source
   */
  public get parentScreenName(): string | undefined {
    return this._parentScreenName;
  }
  /**
   * Setter for attribute {@link _hasToLoadAssets | _hasToLoadAssets}
   * @param {boolean} value - New value of attribute
   * @returns Returns nothing
   * @source
   */
  public set hasToLoadAssets(value: boolean) {
    this._hasToLoadAssets = value;
  }
  /**
   * Protected method to initialize categories.\
   * A category is represented by a {@link Src/Components/CategoryComponent.CategoryComponent | CategoryComponent}
   * @param {(LisioCategory | VisualCategoryNames)[]} categories - Categories to initialize
   * @returns Returns an object containing the component and his position
   * @source
   */
  protected initCategories(
    categories: (LisioCategory | VisualCategoryNames)[],
  ): ComponentAndPosition[] {
    const elements: ComponentAndPosition[] = [];
    for (const category of categories) {
      const renderObject: CategoryRenderObject | undefined =
        this._categoryRenderObjects.get(
          category instanceof LisioCategory ? category.name : category,
        );
      if (renderObject == undefined) {
        throw new Error(
          `No render object defined for ${(category as LisioCategory).name}`,
        );
      } else {
        if (
          this._categoryName != undefined &&
          this._parentScreenName != undefined
        ) {
          renderObject.categoryName = this._categoryName;
          renderObject.parentScreenName = this._parentScreenName;
        }
        renderObject.activeSubObjects = new Set<
          LisioProfileNames | LisioParameterNames
        >();
        const categoryComponent: CategoryComponent = new CategoryComponent(
          renderObject,
        );
        elements.push({
          component: categoryComponent,
          position: renderObject.position,
        });
        renderObject.component = categoryComponent;
      }
    }
    return elements;
  }

  /**
   * Protected method to initialize profiles.\
   * A profile is represented by {@link Src/Components/CustomInput/CustomSwitch.CustomSwitch | CustomSwitch}
   * @param {LisioProfileNames[]} profileNames - Profiles to initialize
   * @param {LisioProfileNames[]} hiddenProfileNames - Profiles to hide
   * @param {LisioProfileNames[] | undefined} savedProfiles - User profiles saved in storage
   * @returns Returns an object containing the component and his position
   * @source
   */
  protected initProfiles(
    profileNames: LisioProfileNames[],
    hiddenProfileNames: LisioProfileNames[],
    savedProfiles?: LisioProfileNames[],
  ): ComponentAndPosition[] {
    const elements: ComponentAndPosition[] = [];
    for (const hiddenProfileName of hiddenProfileNames) {
      InputManager.current.addHiddenProfileOrParameter(hiddenProfileName);
    }
    for (const profileName of profileNames) {
      const renderObject = this._profileRenderObjects.get(profileName);

      if (renderObject == undefined) {
        throw new Error(`No render object defined for ${profileName}`);
      } else {
        if (savedProfiles != undefined) {
          renderObject.value =
            savedProfiles.includes(profileName) &&
            UserController.current.currentUser != undefined &&
            UserController.current.currentUser.customParameters.has(
              LisioBooleanParameterNames.IS_ACTIVE,
            );
        }
        if (
          this._categoryName != undefined &&
          this._parentScreenName != undefined
        ) {
          renderObject.categoryName = this._categoryName;
          renderObject.parentScreenName = this._parentScreenName;
        }
        if (
          renderObject.aria != undefined &&
          renderObject.infoBoxes != undefined
        ) {
          renderObject.aria.describedby = `infobox-${profileName.replace(
            "_",
            "-",
          )}-txt`;
        } else if (renderObject.infoBoxes != undefined) {
          renderObject.aria = {
            describedby: `infobox-${profileName.replace("_", "-")}-txt`,
          };
        }
        const infobox: ElementsContainer | undefined =
          renderObject.infoBoxes == undefined
            ? undefined
            : new ElementsContainer(
                [
                  ...renderObject.infoBoxes.map(
                    (infoBoxRenderObject) =>
                      new CustomText(
                        "p",
                        infoBoxRenderObject.textId,
                        false,
                        infoBoxRenderObject.cssClassesText,
                        undefined,
                        `infobox-${profileName.replace("_", "-")}-txt`,
                        {
                          hidden: true,
                        },
                      ),
                  ),
                  new CustomButton(
                    `infobox-${profileName.replace("_", "-")}-settings-button`,
                    [
                      new CustomText("p", "settings-link-infobox-text", false, [
                        "regular",
                      ]),
                      new CustomIcon("misc-icons", "Arrow", [
                        "grey",
                        "arrow-secondary",
                        "m-left",
                      ]),
                    ],
                    (e) => {
                      ScreenManager.current.changeScreen(
                        "settings-screen",
                        e.detail,
                        true,
                      );
                    },
                    ["infobox-settings-button", "btn-pill", "btn-outline-grey"],
                    {
                      controls: "settings-screen",
                    },
                  ),
                ],
                `infobox-${profileName.replace("_", "-")}`,
                ["infobox-content"],
                new Map<string, string>(),
                {
                  hidden: false,
                },
              );

        const button: CheckboxButton = new CheckboxButton(
          renderObject as ProfileRenderObject,
          this._componentName,
          infobox,
        );

        if (infobox != undefined) {
          const container: LisioComponent = new ElementsContainer(
            [button, infobox],
            undefined,
            ["lisio-button-infobox-container"],
          );
          infobox.parentComponent = container;
          elements.push({
            component: container,
            position: renderObject.position,
          });
        } else if (renderObject.aria?.describedby != undefined) {
          const container: LisioComponent = new ElementsContainer(
            [button],
            undefined,
            ["lisio-button-infobox-container"],
          );
          elements.push({
            component: container,
            position: renderObject.position,
          });
        } else {
          elements.push({
            component: button,
            position: renderObject.position,
          });
        }
      }
    }
    return elements;
  }

  /**
   * Protected method to initialize parameters.\
   * Each types of parameter are represented by :
   *  * Boolean : {@link Src/Components/CustomInput/CustomSwitch.CustomSwitch | CustomSwitch}
   *  * String : {@link Src/Components/CustomInput/CustomChoice.CustomChoice | CustomChoice} for predefined value or {@link Src/Components/CustomInput/CustomTextInput.CustomTextInput | CustomTextInput} for not predefined value
   *  * Numeric : {@link Src/Components/CustomInput/CustomSlider.CustomSlider | CustomSlider}
   * @param {LisioParameterNames[]} parameterNames - Parameters to initialize
   * @param {LisioParameterNames[]} hiddenParameterNames - Parameters to hide
   * @param {Map<LisioParameterNames, LisioParameter> | undefined} savedParameters - User parameters saved in storage
   * @returns Returns an object containing the component and his position
   * @source
   */
  protected initParameters(
    parameterNames: LisioParameterNames[],
    hiddenParameterNames: LisioParameterNames[],
    savedParameters?: Map<LisioParameterNames, LisioParameter>,
  ) {
    const elements: ComponentAndPosition[] = [];
    for (const hiddenParameterName of hiddenParameterNames) {
      InputManager.current.addHiddenProfileOrParameter(hiddenParameterName);
    }
    for (const parameterName of parameterNames) {
      if (parameterName.toUpperCase() in LisioBooleanParameterNames) {
        const renderObject = this._parameterRenderObjects.get(
          parameterName,
        ) as BooleanParameterRenderObject;
        if (renderObject == undefined) {
          throw new Error(`No render object defined for ${parameterName}`);
        } else {
          if (savedParameters != undefined) {
            renderObject.value =
              savedParameters.has(parameterName) &&
              UserController.current.currentUser != undefined &&
              UserController.current.currentUser.customParameters.has(
                LisioBooleanParameterNames.IS_ACTIVE,
              );
          }
          if (
            this._categoryName != undefined &&
            this._parentScreenName != undefined
          ) {
            renderObject.categoryName = this._categoryName;
            renderObject.parentScreenName = this._parentScreenName;
          }
          const infobox: ElementsContainer | undefined =
            renderObject.infoBoxes == undefined
              ? undefined
              : new ElementsContainer(
                  renderObject.infoBoxes.map(
                    (infoBoxRenderObject) =>
                      new CustomText(
                        "p",
                        infoBoxRenderObject.textId,
                        false,
                        infoBoxRenderObject.cssClassesText,
                      ),
                  ),
                  renderObject.infoBoxes[0].textId,
                  undefined,
                  new Map<string, string>(),
                  {
                    hidden: true,
                  },
                );
          const button: CheckboxButton = new CheckboxButton(
            renderObject as BooleanParameterRenderObject,
            this._componentName,
            infobox,
          );
          if (infobox != undefined) {
            const container: LisioComponent = new ElementsContainer(
              [button, infobox],
              undefined,
              ["lisio-button-infobox-container", "w-max"],
            );
            infobox.parentComponent = container;
            elements.push({
              component: container,
              position: renderObject.position,
            });
          } else {
            elements.push({
              component: button,
              position: renderObject.position,
            });
          }
        }
      } else if (parameterName.toUpperCase() in LisioStringParameterNames) {
        const renderObject = this._parameterRenderObjects.get(
          parameterName,
        ) as StringParameterRenderObject;
        if (renderObject == undefined) {
          throw new Error(`No render object defined for ${parameterName}`);
        } else if (renderObject.items.length != 0) {
          if (savedParameters != undefined) {
            const savedParameter: LisioStringParameter | undefined =
              savedParameters.get(parameterName) as
                | LisioStringParameter
                | undefined;
            if (
              savedParameter != undefined &&
              UserController.current.currentUser != undefined &&
              UserController.current.currentUser.customParameters.has(
                LisioBooleanParameterNames.IS_ACTIVE,
              )
            ) {
              const foundItem = renderObject.items.find(
                (item) => item.value === savedParameter.value,
              );
              if (foundItem != undefined) {
                foundItem.isChecked = true;
              }
            }
          }
          elements.push({
            component: new CustomChoice(
              renderObject.items,
              renderObject.name,
              this._componentName,
              this._categoryName,
              this._parentScreenName,
              undefined,
              renderObject.titleId,
              renderObject.defaultText,
              renderObject.cssClasses,
              renderObject.cssClassesItems,
              renderObject.cssClassesLabelItems,
            ),
            position: renderObject.position,
          });
        } else {
          let value = "";
          if (savedParameters != undefined) {
            const savedParameter: LisioStringParameter | undefined =
              savedParameters.get(parameterName) as
                | LisioStringParameter
                | undefined;
            if (savedParameter != undefined) {
              value = savedParameter.value;
            }
          }

          elements.push({
            component: new CustomTextInput(
              renderObject.name as
                | LisioStringParameterNames.UNDERLINE_RED
                | LisioStringParameterNames.UNDERLINE_GREEN
                | LisioStringParameterNames.UNDERLINE_BLUE,
              value,
              this._componentName,
              this._categoryName,
              this._parentScreenName,
              renderObject.titleId,
              renderObject.cssClasses,
              renderObject.aria,
            ),
            position: renderObject.position,
          });
        }
      } else if (parameterName.toUpperCase() in LisioNumericParameterNames) {
        const renderObject = this._parameterRenderObjects.get(
          parameterName,
        ) as NumberParameterRenderObject;
        if (renderObject == undefined) {
          throw new Error(`No render object defined for ${parameterName}`);
        } else {
          if (
            savedParameters != undefined &&
            UserController.current.currentUser != undefined &&
            UserController.current.currentUser.customParameters.has(
              LisioBooleanParameterNames.IS_ACTIVE,
            )
          ) {
            const savedParameter: LisioNumericParameter | undefined =
              savedParameters.get(parameterName) as
                | LisioNumericParameter
                | undefined;
            if (savedParameter != undefined) {
              renderObject.currentValue = savedParameter.value;
            }
          }
          // if(["daltonism_r","daltonism_g","daltonism_b","daltonism_hue","daltonism_saturation","daltonism_brightness","bigger_click"].includes(parameterName)){
              elements.push({
                component: new CustomRange(
                  renderObject.buttonId,
                  renderObject.titleId,
                  renderObject.name,
                  renderObject.defaultValue,
                  renderObject.currentValue,
                  renderObject.minValue,
                  renderObject.maxValue,
                  renderObject.step,
                  this._componentName,
                  this._categoryName,
                  this._parentScreenName,
                  undefined,
                  renderObject.cssClasses,
                  renderObject.icon,
                  renderObject.iconClasses,
                ),
                position: renderObject.position,
              });
            // } else {
            //   elements.push({
            //     component: new CustomSlider(
            //       renderObject.buttonId,
            //       renderObject.titleId,
            //       renderObject.name,
            //       renderObject.defaultValue,
            //       renderObject.currentValue,
            //       renderObject.minValue,
            //       renderObject.maxValue,
            //       renderObject.step,
            //       this._componentName,
            //       this._categoryName,
            //       this._parentScreenName,
            //       undefined,
            //       renderObject.cssClasses,
            //       renderObject.icon,
            //       renderObject.iconClasses,
            //     ),
            //     position: renderObject.position,
            //   });
            // }
        }
      }
    }
    return elements;
  }

  /**
   * Protected method to create the title section.\
   * This method creates a {@link CustomText | CustomText } containing the text corresponding to the given id, and corresponding to the given tagName
   * @param {string} titleId - the textId for the new title
   * @param {"h1" | "h2" | undefined} tagName - the tagName for the DOM element
   * @returns Returns an {@link ElementsContainer | ElementsContainer} containing the created elements
   * @source
   */
  protected createScreenTitle(
    titleId: string,
    tagName?: "h1" | "h2",
    describedby?: string,
  ): ElementsContainer {
    if (tagName == undefined) {
      tagName = "h2";
    }
    this._screenTitle = new CustomText(
      tagName,
      titleId,
      undefined,
      ["tall", "bold", "custom-color"],
      undefined,
      "screen-" + titleId,
      { describedby: describedby },
    );
    return new ElementsContainer([this._screenTitle], undefined, [
      "row",
      "full",
      "transparent",
      "align-items-center",
      "justify-content-center",
    ]);
  }

  /**
   * Protected method to create the subtitle section with back button.\
   * This method does :
   *  * Create a {@link CustomText | CustomText } containing the text corresponding to the given id
   *  * Create a {@link BackButton | BackButton } containing the previous CustomText and sending back to the current ParentScreen, or a manually set screen
   * @param {string} subtitleId - the textId for the new text
   * @returns Returns an {@link BackButton | BackButton}
   * @source
   */
  protected createScreenSubtitle(subtitleId: string): BackButton {
    const backButton = new BackButton(
      "back-button-" + this._componentName,
      subtitleId,
      this._parentScreenName!,
    );

    this._backButton = backButton;

    return backButton;
  }

  /**
   * Protected method to create the footer section at the bottom of some pages.\
   * This method creates a {@link Src/Components/CategoryComponent.CategoryComponent | CategoryComponent } that redirects to the {@link Src/Screens/More.MoreScreen | MoreScreen}
   * @returns Returns the created elements
   * @source
   */
  protected createFooter(
    isCompensation: boolean,
    settings: boolean = false,
  ): LisioComponent[] {
    const footer: ComponentAndPosition = this.initCategories([
      VisualCategoryNames.MORE,
    ])[0];
    if (isCompensation) {
      const icon = new CustomIcon("footer-icons", "Tree", [
        "padding-inline-start-20px",
        "grey2",
      ]);
      const text = new CustomText("span", "carbon-text", undefined, ["small"]);
      const link = new CustomLink(
        "https://lisio.fr/web4green/outils-ecologie-numerique#projets-ecologiques",
        [
          new TextsContainer(
            [
              new CustomText("p", "link-eco", false, [
                "small",
                "underline",
                "center",
              ]),
              //new CustomIcon("footer-icons", "NewTab", []),
            ],
            ["new-tab", "d-inline"],
          ),
        ],
        undefined,
        undefined,
        [],
        "link-eco-title",
      );
      const textContainer = new TextsContainer(
        [text, link],
        ["d-block", "carbon-text-container", "padding-left-right-15px"],
      );
      const container = new ElementsContainer(
        [icon, textContainer],
        undefined,
        [
          "medium",
          "secondary",
          "footer",
          "justify-content-around",
          "align-items-center",
          settings ? "no-before" : "",
        ],
      );
      const acces = new CustomLink(
        "https://lisio.fr/upload/pdf/Declaration_accessibilite_RGAA_4_%20Widget_Lisio.pdf",
        [
          new TextsContainer(
            [
              new CustomText("p", "acces-text", false, [
                "small",
                "underline",
                "center",
              ]),
              //new CustomIcon("footer-icons", "NewTab", []),
            ],
            ["new-tab"],
          ),
        ],
        undefined,
        undefined,
        ["tiny", "text-center", "black"],
        "rgaa-compliant-title",
      );
      const footerCSSClass: string[] = [
        "secondary",
        "full",
        "column",
        "lines-h",
      ];
      const footerContainer = new ListContainer(
        [footer.component],
        undefined,
        settings == false
          ? footerCSSClass
          : footerCSSClass.concat("margin-top-bot-minus-25px"),
      );
      return [container, footerContainer, acces];
    } else {
      const acces = new CustomLink(
        "https://lisio.fr/upload/pdf/Declaration_accessibilite_RGAA_4_%20Widget_Lisio.pdf",
        [
          new TextsContainer(
            [
              new CustomText("p", "acces-text", false, [
                "small",
                "underline",
                "center",
              ]),
              //new CustomIcon("footer-icons", "NewTab", []),
            ],
            ["new-tab"],
          ),
        ],
        undefined,
        undefined,
        ["tiny", "text-center", "black"],
        "rgaa-compliant-title",
      );
      const footerCSSClass: string[] = [
        "secondary",
        "footer",
        "full",
        "column",
        "lines-h",
        settings ? "no-before" : "",
      ];
      const footerContainer = new ListContainer(
        [footer.component],
        undefined,
        settings == false
          ? footerCSSClass
          : footerCSSClass.concat("margin-top-bot-minus-25px"),
      );
      return [footerContainer, acces];
    }
  }

  /**
   * Constructor of class {@link LisioScreen | LisioScreen}
   * @param {string} componentName - Component name
   * @param {string} id - Id of component
   * @param {MergedCategoriesNames | undefined} categoryName - Category name containing parameter or profile related to this input
   * @param {string | undefined} parentScreenName - Parent screen name in screen tree
   */
  constructor(
    componentName: string,
    id?: string,
    categoryName?: MergedCategoriesNames,
    parentScreenName?: string,
  ) {
    super(
      ScreenNames[componentName],
      id == undefined ? undefined : ScreenNames[id],
    );
    this._categoryName = categoryName;
    this._parentScreenName = parentScreenName;
  }
}

export { LisioScreen };