import frappe from 'frappe';
import { validTypes } from 'frappe/backends/helpers';
import { ValueError } from 'frappe/utils/errors';
import { indicators as indicatorColor } from '../../src/colors';
import { t } from '../utils/translation';
import Document from './document';
import model from './index';

export default class Meta extends Document {
  filters;
  basedOn;

  constructor(data) {
    if (data.basedOn) {
      let config = frappe.models[data.basedOn];
      Object.assign(data, config, {
        name: data.name,
        label: data.label,
        filters: data.filters,
      });
    }
    super(data);
    this.setDefaultIndicators();
    if (this.setupMeta) {
      this.setupMeta();
    }
    if (!this.titleField) {
      this.titleField = 'name';
    }
  }

  setValues(data) {
    Object.assign(this, data);
    this.processFields();
  }

  processFields() {
    // add name field
    if (!this.fields.find((df) => df.fieldname === 'name') && !this.isSingle) {
      this.fields = [
        {
          label: t`ID`,
          fieldname: 'name',
          fieldtype: 'Data',
          required: 1,
          readOnly: 1,
        },
      ].concat(this.fields);
    }

    this.fields = this.fields.map((df) => {
      // name field is always required
      if (df.fieldname === 'name') {
        df.required = 1;
      }

      return df;
    });
  }

  hasField(fieldname) {
    return this.getField(fieldname) ? true : false;
  }

  getField(fieldname) {
    if (!this._field_map) {
      this._field_map = {};
      for (let field of this.fields) {
        this._field_map[field.fieldname] = field;
      }
    }
    return this._field_map[fieldname];
  }

  /**
   * Get fields filtered by filters
   * @param {Object} filters
   *
   * Usage:
   *   meta = frappe.getMeta('ToDo')
   *   dataFields = meta.getFieldsWith({ fieldtype: 'Data' })
   */
  getFieldsWith(filters) {
    return this.fields.filter((df) => {
      let match = true;
      for (const key in filters) {
        const value = filters[key];
        match = df[key] === value;
      }
      return match;
    });
  }

  getLabel(fieldname) {
    let df = this.getField(fieldname);
    return df.getLabel || df.label;
  }

  getTableFields() {
    if (this._tableFields === undefined) {
      this._tableFields = this.fields.filter(
        (field) => field.fieldtype === 'Table'
      );
    }
    return this._tableFields;
  }

  getFormulaFields() {
    if (this._formulaFields === undefined) {
      this._formulaFields = this.fields.filter((field) => field.formula);
    }
    return this._formulaFields;
  }

  hasFormula() {
    if (this._hasFormula === undefined) {
      this._hasFormula = false;
      if (this.getFormulaFields().length) {
        this._hasFormula = true;
      } else {
        for (let tablefield of this.getTableFields()) {
          if (frappe.getMeta(tablefield.childtype).getFormulaFields().length) {
            this._hasFormula = true;
            break;
          }
        }
      }
    }
    return this._hasFormula;
  }

  getBaseDocType() {
    return this.basedOn || this.name;
  }

  async set(fieldname, value) {
    this[fieldname] = value;
    await this.trigger(fieldname);
  }

  get(fieldname) {
    return this[fieldname];
  }

  getValidFields({ withChildren = true } = {}) {
    if (!this._validFields) {
      this._validFields = [];
      this._validFieldsWithChildren = [];

      const _add = (field) => {
        this._validFields.push(field);
        this._validFieldsWithChildren.push(field);
      };

      // fields validation
      this.fields.forEach((df, i) => {
        if (!df.fieldname) {
          throw new ValidationError(
            `DocType ${this.name}: "fieldname" is required for field at index ${i}`
          );
        }
        if (!df.fieldtype) {
          throw new ValidationError(
            `DocType ${this.name}: "fieldtype" is required for field "${df.fieldname}"`
          );
        }
      });

      const doctypeFields = this.fields.map((field) => field.fieldname);

      // standard fields
      for (let field of model.commonFields) {
        if (
          validTypes.includes(field.fieldtype) &&
          !doctypeFields.includes(field.fieldname)
        ) {
          _add(field);
        }
      }

      if (this.isSubmittable) {
        _add({
          fieldtype: 'Check',
          fieldname: 'submitted',
          label: t`Submitted`,
        });
      }

      if (this.isChild) {
        // child fields
        for (let field of model.childFields) {
          if (
            validTypes.includes(field.fieldtype) &&
            !doctypeFields.includes(field.fieldname)
          ) {
            _add(field);
          }
        }
      } else {
        // parent fields
        for (let field of model.parentFields) {
          if (
            validTypes.includes(field.fieldtype) &&
            !doctypeFields.includes(field.fieldname)
          ) {
            _add(field);
          }
        }
      }

      if (this.isTree) {
        // tree fields
        for (let field of model.treeFields) {
          if (
            validTypes.includes(field.fieldtype) &&
            !doctypeFields.includes(field.fieldname)
          ) {
            _add(field);
          }
        }
      }

      // doctype fields
      for (let field of this.fields) {
        const include = validTypes.includes(field.fieldtype);

        if (include) {
          _add(field);
        }

        // include tables if (withChildren = True)
        if (!include && field.fieldtype === 'Table') {
          this._validFieldsWithChildren.push(field);
        }
      }
    }

    if (withChildren) {
      return this._validFieldsWithChildren;
    } else {
      return this._validFields;
    }
  }

  getKeywordFields() {
    if (!this._keywordFields) {
      this._keywordFields = this.keywordFields;
      if (!(this._keywordFields && this._keywordFields.length && this.fields)) {
        this._keywordFields = this.fields
          .filter((field) => field.fieldtype !== 'Table' && field.required)
          .map((field) => field.fieldname);
      }
      if (!(this._keywordFields && this._keywordFields.length)) {
        this._keywordFields = ['name'];
      }
    }
    return this._keywordFields;
  }

  getQuickEditFields() {
    if (this.quickEditFields) {
      return this.quickEditFields.map((fieldname) => this.getField(fieldname));
    }
    return this.getFieldsWith({ required: 1 });
  }

  validateSelect(field, value) {
    let options = field.options;
    if (!options) return;
    if (!field.required && value == null) {
      return;
    }

    let validValues = options;

    if (typeof options === 'string') {
      // values given as string
      validValues = options.split('\n');
    }

    if (typeof options[0] === 'object') {
      // options as array of {label, value} pairs
      validValues = options.map((o) => o.value);
    }

    if (!validValues.includes(value)) {
      throw new ValueError(
        // prettier-ignore
        `DocType ${this.name}: Invalid value "${value}" for "${field.label}". Must be one of ${options.join(', ')}`
      );
    }
    return value;
  }

  async trigger(event, params = {}) {
    Object.assign(params, {
      doc: this,
      name: event,
    });

    await super.trigger(event, params);
  }

  setDefaultIndicators() {
    if (!this.indicators) {
      if (this.isSubmittable) {
        this.indicators = {
          key: 'submitted',
          colors: {
            0: indicatorColor.GRAY,
            1: indicatorColor.BLUE,
          },
        };
      }
    }
  }

  getIndicatorColor(doc) {
    if (frappe.isDirty(this.name, doc.name)) {
      return indicatorColor.ORANGE;
    } else {
      if (this.indicators) {
        let value = doc[this.indicators.key];
        if (value) {
          return this.indicators.colors[value] || indicatorColor.GRAY;
        } else {
          return indicatorColor.GRAY;
        }
      } else {
        return indicatorColor.GRAY;
      }
    }
  }
}