/* eslint-disable max-classes-per-file */
import DG, { BASE_TEMPLATE_PATH } from "./config.js";
import DGActorSheet from "./sheets/base-actor-sheet.js";
import DGItemSheet from "./sheets/base-item-sheet.js";

const { ApplicationV2, HandlebarsApplicationMixin } = foundry.applications.api;

/**
 * Base class for all setting forms.
 *
 * Note: This class is abstract and should not be instantiated directly.
 *
 * @extends {ApplicationV2}
 */
const SettingForm = class extends HandlebarsApplicationMixin(ApplicationV2) {
  /** @type {"automation"|"handler"|null} */
  static _namespace = null;

  /**
   * The namespace for the settings defined by this class. This is necessary
   * to register the settings with the game.
   *
   * @returns {string}
   */
  static get namespace() {
    return this._namespace;
  }

  /**
   * A getter that returns an object with all the settings defined by the subclass.
   * Used to register settings with the game.
   *
   * @abstract
   * @returns {object} An object with all the settings defined by the subclass
   * @throws Will throw an error if this method is not defined by a subclass.
   */
  static get settings() {
    throw new Error("This static getter must be defined by a subclass");
  }

  /**
   * Registers the settings for each defined SettingForm subclass.
   * @returns {void}
   */
  static register() {
    const { settings } = this;
    for (const [settingID, setting] of Object.entries(settings)) {
      game.settings.register(DG.ID, settingID, {
        scope: "world",
        config: false,
        name: game.i18n.localize(`DG.Settings.${settingID}.name`),
        hint: game.i18n.localize(`DG.Settings.${settingID}.hint`),
        ...setting,
      });
    }
  }

  /** @override */
  static DEFAULT_OPTIONS = {
    tag: "form",
    id: "dg-settings",
    classes: [DG.ID, "settings-menu"],
    window: { contentClasses: ["standard-form"], resizable: true },
    position: { width: 500, height: "auto" },
    actions: {},
    form: {
      handler: this.onSubmit,
      submitOnChange: false,
      closeOnSubmit: true,
    },
  };

  /** @override */
  static PARTS = {
    footer: { template: `${BASE_TEMPLATE_PATH}/save.hbs` },
  };

  /** @override */
  static async onSubmit(event, form, formData) {
    event.preventDefault();
    // Get form data into a standard object.
    const data = foundry.utils.expandObject(formData.object);

    const settingsPromises = [];
    // Set each setting with the new value, if any.
    for (const [key, value] of Object.entries(data[DG.ID])) {
      settingsPromises.push(game.settings.set(DG.ID, key, value));
    }

    // Once all promises resolve, show a notification.
    Promise.allSettled(settingsPromises).then((values) => {
      ui.notifications.info(game.i18n.localize("DG.Settings.Saved"));
    });
  }

  /** @override */
  _onFirstRender(options) {
    super._onFirstRender(options);

    this._attachFormGroupHTML();
  }

  /**
   * Populate the window content section with form groups representing the settings.
   * @returns {void}
   */
  _attachFormGroupHTML() {
    const windowContent = this.element.querySelector("section.window-content");
    const formGroupString = this._prepareFormGroupElements()
      .map((formGroup) => formGroup.outerHTML)
      .join("");

    // Create a div element whose inner html is the form groups (as a string of HTML),
    // and prepend it to the window content.
    const div = document.createElement("div");
    div.classList.add("flexcol");
    div.innerHTML = formGroupString;
    windowContent.prepend(div);
  }

  /**
   * Generates an array of form groups, each corresponding to a setting in a menu.
   * @returns {HTMLDivElement[]} An array of form group HTML elements.
   */
  _prepareFormGroupElements() {
    // Get Foundry's built-in input creation functions.
    const {
      createCheckboxInput,
      createNumberInput,
      createSelectInput,
      createTextInput,
      createFormGroup,
    } = foundry.applications.fields;
    const formGroups = [];

    // Iterate over each setting and create the appropriate input element.
    const { settings } = this.constructor;
    for (const settingID of Object.keys(settings)) {
      // The setting config object, not the value of the setting itself.
      const settingConfig = game.settings.settings.get(`${DG.ID}.${settingID}`);

      // Default input settings.
      const inputConfig = {
        name: `${DG.ID}.${settingID}`,
        value: game.settings.get(DG.ID, settingID), // The value that the setting is currently set to.
        label: settingConfig.name,
      };

      // Use Foundry's built-in <input>/<select> creation functions.
      let input;
      if (settingConfig.type === String && settingConfig.choices) {
        // Select Input
        const choices = Object.entries(settingConfig.choices);
        const options = choices.map(([value, label]) => ({
          value,
          label,
        }));
        input = createSelectInput({
          ...inputConfig,
          options,
          localize: true,
        });
      } else if (settingConfig.type === String) {
        // Text Input
        input = createTextInput({
          ...inputConfig,
        });
      } else if (settingConfig.type === Number) {
        // Number Input
        input = createNumberInput({
          ...inputConfig,
          ...settingConfig.range,
        });
      } else if (settingConfig.type === Boolean) {
        // Checkbox
        input = createCheckboxInput({
          ...inputConfig,
        });
      }

      // Create a Form Group, which generates all of the HTML for a single setting.
      // It includes a label and hint.
      formGroups.push(
        createFormGroup({
          input,
          hint: settingConfig.hint,
          label: settingConfig.name,
          localize: true,
          rootId: this.options.id,
        }),
      );
    }

    return formGroups;
  }
};

/**
 * Defines the Automation Settings form.
 *
 * @extends {SettingForm}
 */
class AutomationSettings extends SettingForm {
  /** @override */
  static _namespace = "automation";

  /** @override */
  static DEFAULT_OPTIONS = {
    id: `${super.DEFAULT_OPTIONS.id}-${this.namespace ?? ""}`,
    window: { title: "DG.SettingsMenu.automation.title" },
  };

  /** @override */
  static get settings() {
    return {
      skillFailure: {
        default: false,
        type: Boolean,
      },
    };
  }
}

/**
 * Defines the Handler-only Settings form.
 *
 * @extends {SettingForm}
 */
class HandlerSettings extends SettingForm {
  /** @override */
  static _namespace = "handler";

  /** @override */
  static DEFAULT_OPTIONS = {
    id: `${super.DEFAULT_OPTIONS.id}-${this.namespace ?? ""}`,
    window: { title: "DG.SettingsMenu.handler.title" },
  };

  /** @override */
  static get settings() {
    return {
      alwaysShowHypergeometrySectionForPlayers: {
        requiresReload: true,
        type: Boolean,
        default: false,
      },
      showImpossibleLandscapesContent: {
        requiresReload: true,
        type: Boolean,
        default: true,
      },
      keepSanityPrivate: {
        requiresReload: true,
        type: Boolean,
        default: false,
      },
      skillImprovementFormula: {
        type: String,
        choices: DG.skillImprovementFormulas,
        default: "d4",
      },
    };
  }
}

export default function registerSystemSettings() {
  game.settings.registerMenu(DG.ID, "automation", {
    name: game.i18n.localize(`DG.SettingsMenu.automation.name`),
    label: game.i18n.localize(`DG.SettingsMenu.automation.label`),
    hint: "",
    icon: "fa-solid fa-dice",
    type: AutomationSettings,
    restricted: true,
  });
  AutomationSettings.register();

  game.settings.registerMenu(DG.ID, "handler", {
    name: game.i18n.localize(`DG.SettingsMenu.handler.name`),
    label: game.i18n.localize(`DG.SettingsMenu.handler.label`),
    hint: "",
    icon: "fa-solid fa-dice",
    type: HandlerSettings,
    restricted: true,
  });
  HandlerSettings.register();

  game.settings.register("deltagreen", "characterSheetStyle", {
    name: game.i18n.localize("DG.Settings.charactersheet.name"),
    hint: game.i18n.localize("DG.Settings.charactersheet.hint"),
    scope: "world", // This specifies a world-stored setting
    config: true, // This specifies that the setting appears in the configuration view
    requiresReload: true,
    type: String,
    choices: {
      // If choices are defined, the resulting setting will be a select menu
      cowboy: game.i18n.localize("DG.Settings.charactersheet.cowboys"),
      outlaw: game.i18n.localize("DG.Settings.charactersheet.outlaws"),
      program: game.i18n.localize("DG.Settings.charactersheet.program"),
    },
    default: "program", // The default value for the setting
    onChange: (value) => {
      // A callback function which triggers when the setting is changed
      // console.log(value)
    },
  });

  game.settings.register("deltagreen", "sortSkills", {
    name: game.i18n.localize("DG.Settings.sortskills.name"),
    hint: game.i18n.localize("DG.Settings.sortskills.hint"),
    scope: "client",
    config: true,
    requiresReload: true,
    type: Boolean,
    default: false,
  });

  game.settings.register("deltagreen", "skillTooltipDisplay", {
    name: game.i18n.localize("DG.Settings.skillTooltipDisplay.name"),
    hint: game.i18n.localize("DG.Settings.skillTooltipDisplay.hint"),
    scope: "client",
    config: true,
    type: String,
    choices: {
      hover: game.i18n.localize("DG.Settings.skillTooltipDisplay.hover"),
      never: game.i18n.localize("DG.Settings.skillTooltipDisplay.never"),
      hoverShift: game.i18n.localize(
        "DG.Settings.skillTooltipDisplay.hoverShift",
      ),
    },
    default: "hover",
    onChange: () => {
      foundry.applications.instances.forEach((app) => {
        if (app instanceof DGActorSheet || app instanceof DGItemSheet) {
          app.render();
        }
      });
    },
  });

  game.settings.register(DG.ID, "schemaMigrationVersion", {
    name: "Schema Migration Version",
    scope: "world",
    config: false,
    type: Number,
    default: 0,
  });
}