import { BasicType, DBColumn, ObjectData, PrimitiveData, Scope, Variable } from '@cyklang/core';
import loglevel from 'loglevel';
import { ChangeWorker, structure, useCykLang } from './cykLang';
import { ComponentModel } from './cykLang'
// import { structure } from 'src/services/cyklang';
import { computed, onUnmounted, ref, watch } from 'vue';
import { ComponentModelParameter, componentModelParameter } from './cykReact';
import { RowObject } from './cykTableEdit';
const logger = loglevel.getLogger('CheckboxComponent.vue');
logger.setLevel('info');


export function useCykCheckbox(props: { componentArg: ComponentModel | undefined, readonly: Boolean }) {

  const { structure, getDBManager } = useCykLang();
  logger.debug('====  CheckboxComponent');
  const debug_label =
    props.componentArg?.objectData?.tag.attributes.LABEL || 'no label';

  const isLoading = ref(true);
  const visible = componentModelParameter<boolean>(props.componentArg, "visible", true)

  const cpLocked = new ComponentModelParameter<boolean>(props.componentArg, "locked", false)
  const locked = cpLocked.model

  const label = componentModelParameter<string>(props.componentArg, "label", structure.scope.xlate(props.componentArg?.objectData?.tag.attributes.LABEL))
  const tooltip = componentModelParameter<string>(props.componentArg, "tooltip", structure.scope.xlate(props.componentArg?.objectData?.tag.attributes.TOOLTIP))

  const disable = ref(false)

  const refCompute = ref<Variable>();

  // onchange

  let changeWorker: ChangeWorker | undefined

  const onchangeFunction = props.componentArg?.objectData?.variables.getFunction('onchange');
  if (onchangeFunction && props.componentArg?.objectData) {
    changeWorker = new ChangeWorker(onchangeFunction, props.componentArg?.objectData.scope)
  }

  /**
   * 
   */
  const doLoading = async () => {

    try {
      await props.componentArg?.interpolateAttributes()

      const dbManager = await getDBManager();
      refCompute.value = new Variable(dbManager.scope.structure.stringDataType);

      if (props.readonly || locked.value) {
        disable.value = true
      }
      else {
        disable.value = false
      }

    }
    catch (err) {
      logger.error(err)
    }
    finally {
      isLoading.value = false;
    }
  }

  doLoading()

  const model = computed({
    get() {
      let result;
      const variable = props.componentArg?.model;
      if (
        variable !== undefined &&
        variable.data !== null &&
        variable.data !== undefined
      ) {
        result = variable.getPrimitiveValue();
      }
      logger.debug('Checkbox.get ' + String(result));
      if (typeof result !== 'boolean')
        logger.debug(' return type is not boolean');
      return result;
    },
    set(nval) {
      logger.debug('Checkbox.set ' + nval);
      if (typeof nval !== 'boolean') logger.debug('set type is not boolean');

      const variable = props.componentArg?.model;
      if (variable !== undefined) {
        const dataTypeName = variable.dataType.name;
        let ndata;
        if (dataTypeName === 'string') {
          const strin = String(nval);
          ndata = new PrimitiveData(structure.stringDataType, strin);
          variable.setValue(ndata);
        } else if (dataTypeName === 'number') {
          const numb = Number(nval);
          if (!isNaN(numb)) {
            ndata = new PrimitiveData(structure.numberDataType, Number(nval));
            variable.setValue(ndata);
          }
        } else if (dataTypeName === 'boolean') {
          const bool = Boolean(nval);
          ndata = new PrimitiveData(structure.booleanDataType, bool);
          variable.setValue(ndata);
          logger.debug('set boolean ' + ndata);
        } else if (dataTypeName === 'datetime') {
          let dat;
          if (nval === null) {
            logger.debug('>> set date null');
            dat = null;
          } else if (nval === undefined) {
            logger.debug('>> set date undefined');
            dat = null;
          } else if (nval === '') {
            logger.debug('>> set date blank');
            dat = null;
          } else {
            logger.debug('>> set date ' + nval);
            dat = new Date(String(nval));
          }

          logger.debug('set date ' + dat);
          ndata = new PrimitiveData(structure.datetimeDataType, dat);
          variable.setValue(ndata);
        }
      }
      // console.log(nval);
    },
  });

  const slots = ref(new Map<string, string>());
  props.componentArg?.objectData?.tag.childs.forEach((child: any) => {
    if (child.name === 'TEMPLATE') {
      slots.value.set(child.attributes.NAME, child.getText());
    }
  });

  if (
    props.componentArg !== undefined &&
    props.componentArg.model !== undefined && props.componentArg.dirtyManager
    && props.componentArg.objectData?.tag.attributes['IGNORE-DIRTY'] === undefined    
  )
    props.componentArg.dirtyManager.registerVariable(
      props.componentArg.model,
      props.componentArg.objectData?.tag.attributes.LABEL || 'no label'
    );

  watch(model, (first, second) => {

    changeWorker?.onchangeRequired()

    if (
      props.componentArg === undefined ||
      props.componentArg.model === undefined
    )
      return;

    logger.debug(
      '===== watch ' + debug_label + ' new ' + first + ' old ' + second
    );
    props.componentArg.dirtyManager?.variableChanged(props.componentArg.model)

  })

  watch([locked],
    () => {
      isLoading.value = true
      doLoading()
    })


  onUnmounted(() => {
    props.componentArg?.objectData?.destroy()
    cpLocked.destroy()
  });

  return { isLoading, visible, label, disable, model, slots };
}

/**
 * 
 * @param props 
 */
export function useCykCheckboxCell(props: { row: RowObject | undefined, dbColumn: DBColumn | undefined, scopeRow: Scope | undefined }) {

  const isLoading = ref(true);
  const disable = ref(true);

  // onchange

  let changeWorker: ChangeWorker | undefined

  const onchangeFunction = props.dbColumn?.params?.getFunction('onchange');
  if (onchangeFunction && props.scopeRow) {
    changeWorker = new ChangeWorker(onchangeFunction, props.scopeRow)
  }

  const doLoading = async () => {
    try {
      const dataLocked = props.dbColumn?.params?.getData('locked')
      if (dataLocked && dataLocked !== null && dataLocked.type.isPrimitive()) {
        disable.value = Boolean((dataLocked as PrimitiveData).value)
      }
    }
    catch (err) {
      logger.error(err)
    }
    finally {
      isLoading.value = false
    }
  }

  doLoading();

  const model = computed({
    get() {
      let result: BasicType
      if (!props.row) return
      if (!props.dbColumn) return
      const variable = props.row.objectData.variables.getVariable(props.dbColumn.name)
      if (!variable || !variable.data) return
      if (!variable.data.type.isPrimitive()) return
      result = (variable.data as PrimitiveData).value
      return result
    },
    set(nval) {
      if (typeof nval !== 'boolean') {
        logger.debug('nval', nval)
        throw 'nval is not boolean'
      }
      if (!props.row) return
      if (!props.dbColumn) return
      const variable = props.row.objectData.variables.getVariable(props.dbColumn.name)
      if (!variable) return
      variable.data = new PrimitiveData(structure.booleanDataType, nval)

    }
  },
  )

  watch(model, () => {
    changeWorker?.onchangeRequired()
  })

  return { isLoading, model, disable }
}