/*
 This file is part of GNU Taler
 (C) 2022-2024 Taler Systems S.A.

 GNU Taler is free software; you can redistribute it and/or modify it under the
 terms of the GNU General Public License as published by the Free Software
 Foundation; either version 3, or (at your option) any later version.

 GNU Taler is distributed in the hope that it will be useful, but WITHOUT ANY
 WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.  See the GNU General Public License for more details.

 You should have received a copy of the GNU General Public License along with
 GNU Taler; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>
 */

import {
  AbsoluteTime,
  AmountJson,
  TalerExchangeApi,
  TranslatedString,
  assertUnreachable,
} from "@gnu-taler/taler-util";
import { Addon, InternationalizationAPI, UIFieldBaseDescription, UIFieldHandler, UIFormField, UIFormFieldBaseConfig, UIFormFieldConfig, UIHandlerId } from "@gnu-taler/web-util/browser";
import { useState } from "preact/hooks";
import { getConverterById } from "../utils/converter.js";

// export type UIField = {
//   value: string | undefined;
//   onUpdate: (s: string) => void;
//   error: TranslatedString | undefined;
// };

export type FormHandler<T> = {
  [k in keyof T]?: T[k] extends string
    ? UIFieldHandler
    : T[k] extends AmountJson
      ? UIFieldHandler
      : T[k] extends TalerExchangeApi.AmlState
        ? UIFieldHandler
        : FormHandler<T[k]>;
};

export type FormValues<T> = {
  [k in keyof T]: T[k] extends string ? string | undefined : FormValues<T[k]>;
};

export type RecursivePartial<T> = {
  [k in keyof T]?: T[k] extends string
    ? string
    : T[k] extends AmountJson
      ? AmountJson
      : T[k] extends TalerExchangeApi.AmlState
        ? TalerExchangeApi.AmlState
        : RecursivePartial<T[k]>;
};

export type FormErrors<T> = {
  [k in keyof T]?: T[k] extends string
    ? TranslatedString
    : T[k] extends AmountJson
      ? TranslatedString
      : T[k] extends AbsoluteTime
      ? TranslatedString
      : T[k] extends TalerExchangeApi.AmlState
        ? TranslatedString
        : FormErrors<T[k]>;
};

export type FormStatus<T> =
  | {
      status: "ok";
      result: T;
      errors: undefined;
    }
  | {
      status: "fail";
      result: RecursivePartial<T>;
      errors: FormErrors<T>;
    };

function constructFormHandler<T>(
  shape: Array<UIHandlerId>,
  form: RecursivePartial<FormValues<T>>,
  updateForm: (d: RecursivePartial<FormValues<T>>) => void,
  errors: FormErrors<T> | undefined,
): FormHandler<T> {

  const handler = shape.reduce((handleForm, fieldId) => {

    const path = fieldId.split(".")
    
    function updater(newValue: unknown) {
      updateForm(setValueDeeper(form, path, newValue));
    }

    const currentValue = getValueDeeper<string>(form as any, path, undefined)
    const currentError = getValueDeeper<TranslatedString>(errors as any, path, undefined)
    const field: UIFieldHandler = {
      error: currentError,
      value: currentValue,
      onChange: updater,
      state: {}, //FIXME: add the state of the field (hidden, )
    };

    return setValueDeeper(handleForm, path, field)

  }, {} as FormHandler<T>);

  return handler;
}


/**
 * FIXME: Consider sending this to web-utils
 *
 *
 * @param defaultValue
 * @param check
 * @returns
 */
export function useFormState<T>(
  shape: Array<UIHandlerId>,
  defaultValue: RecursivePartial<FormValues<T>>,
  check: (f: RecursivePartial<FormValues<T>>) => FormStatus<T>,
): [FormHandler<T>, FormStatus<T>] {
  const [form, updateForm] =
    useState<RecursivePartial<FormValues<T>>>(defaultValue);

  const status = check(form);
  const handler = constructFormHandler(shape, form, updateForm, status.errors);

  return [handler, status];
}

interface Tree<T> extends Record<string, Tree<T> | T> {}

function getValueDeeper<T>(
  object: Tree<T> | undefined,
  names: string[],
  notFoundValue?: T,
): T | undefined {
  if (names.length === 0) return object as T;
  const [head, ...rest] = names;
  if (!head) {
    return getValueDeeper(object, rest, notFoundValue);
  }
  if (object === undefined) {
    return notFoundValue
  }
  return getValueDeeper(object[head] as Tree<T>, rest, notFoundValue);
}

function getValueDeeper2(
  object: Record<string, any>,
  names: string[],
): UIFieldHandler {
  if (names.length === 0) return object as UIFieldHandler;
  const [head, ...rest] = names;
  if (!head) {
    return getValueDeeper2(object, rest);
  }
  if (object === undefined) {
    throw Error("handler not found");
  }
  return getValueDeeper2(object[head], rest);
}


function setValueDeeper(object: any, names: string[], value: any): any {
  if (names.length === 0) return value;
  const [head, ...rest] = names;
  if (!head) {
    return setValueDeeper(object, rest, value);
  }
  if (object === undefined) {
    return { [head]: setValueDeeper({}, rest, value) };
  }
  return { ...object, [head]: setValueDeeper(object[head] ?? {}, rest, value) };
}

function getAddonById(_id: string | undefined): Addon {
  return undefined!;
}


function converInputFieldsProps(
  form: FormHandler<unknown>,
  p: UIFormFieldBaseConfig,
) {
  return {
    converter: getConverterById(p.converterId, p),
    handler: getValueDeeper2(form, p.id.split(".")),
    name: p.name,
    required: p.required,
    disabled: p.disabled,
    help: p.help,
    placeholder: p.placeholder,
    tooltip: p.tooltip,
    label: p.label as TranslatedString,
  };
}

function converBaseFieldsProps(
  i18n_: InternationalizationAPI,
  p: UIFieldBaseDescription,
) {
  return {
    after: getAddonById(p.addonAfterId),
    before: getAddonById(p.addonBeforeId),
    hidden: p.hidden,
    name: p.name,
    help: i18n_.str`${p.help}`,
    label: i18n_.str`${p.label}`,
    tooltip: i18n_.str`${p.tooltip}`,
  };
}

export function convertUiField(
  i18n_: InternationalizationAPI,
  fieldConfig: UIFormFieldConfig[],
  form: FormHandler<unknown>,
): UIFormField[] {
  return fieldConfig.map((config) => {
    // NON input fields
    switch (config.type) {
      case "caption": {
        const resp: UIFormField = {
          type: config.type,
          properties: converBaseFieldsProps(i18n_, config.properties),
        };
        return resp;
      }
      case "group": {
        const resp: UIFormField = {
          type: config.type,
          properties: {
            ...converBaseFieldsProps(i18n_, config.properties),
            fields: convertUiField(i18n_, config.properties.fields, form),
          },
        };
        return resp;
      }
    }
    // Input Fields
    switch (config.type) {
      case "array": {
        return {
          type: "array",
          properties: {
            ...converBaseFieldsProps(i18n_, config.properties),
            ...converInputFieldsProps(form, config.properties),
            labelField: config.properties.labelFieldId,
            fields: convertUiField(i18n_, config.properties.fields, form),
          },
        } as UIFormField;
      }
      case "absoluteTime": {
        return {
          type: "absoluteTime",
          properties: {
            ...converBaseFieldsProps(i18n_, config.properties),
            ...converInputFieldsProps(form, config.properties),
          },
        } as UIFormField;
      }
      case "amount": {
        return {
          type: "amount",
          properties: {
            ...converBaseFieldsProps(i18n_, config.properties),
            ...converInputFieldsProps(form, config.properties),            
          },
        } as UIFormField;
      }
      case "choiceHorizontal": {
        return {
          type: "choiceHorizontal",
          properties: {
            ...converBaseFieldsProps(i18n_, config.properties),
            ...converInputFieldsProps(form, config.properties),
            choices: config.properties.choices,
          },
        } as UIFormField;
      }
      case "choiceStacked": {
        return {
          type: "choiceStacked",
          properties: {
            ...converBaseFieldsProps(i18n_, config.properties),
            ...converInputFieldsProps(form, config.properties),
            choices: config.properties.choices,
            
          },
        }as UIFormField;
      }
      case "file":{
        console.log("ASDASD", config.properties.accept)
        return {
          type: "file",
          properties: {
            ...converBaseFieldsProps(i18n_, config.properties),
            ...converInputFieldsProps(form, config.properties),
            accept: config.properties.accept,
            maxBites: config.properties.maxBytes,
          },
        } as UIFormField;
      }
      case "integer":{
        return {
          type: "integer",
          properties: {
            ...converBaseFieldsProps(i18n_, config.properties),
            ...converInputFieldsProps(form, config.properties),
          },
        } as UIFormField;
      }
      case "selectMultiple":{
        return {
          type: "selectMultiple",
          properties: {
            ...converBaseFieldsProps(i18n_, config.properties),
            ...converInputFieldsProps(form, config.properties),
            choices: config.properties.choices,
          },
        } as UIFormField;
      }
      case "selectOne": {
        return {
          type: "selectOne",
          properties: {
            ...converBaseFieldsProps(i18n_, config.properties),
            ...converInputFieldsProps(form, config.properties),
            choices: config.properties.choices,
          },
        } as UIFormField;
      }
      case "text": {
        return {
          type: "text",
          properties: {
            ...converBaseFieldsProps(i18n_, config.properties),
            ...converInputFieldsProps(form, config.properties),
          },
        } as UIFormField;
      }
      case "textArea": {
        return {
          type: "text",
          properties: {
            ...converBaseFieldsProps(i18n_, config.properties),
            ...converInputFieldsProps(form, config.properties),
          },
        } as UIFormField;
      }
      case "toggle": {
        return {
          type: "toggle",
          properties: {
            ...converBaseFieldsProps(i18n_, config.properties),
            ...converInputFieldsProps(form, config.properties),
          },
        } as UIFormField;
      }
      default: {
        assertUnreachable(config);
      }
    }
  });
}