text: import { inject as service } from '@ember/service';
  import { validateChars, validateLength } from '@rancher/ember-api-store/utils/validate';
  import Resource from '@rancher/ember-api-store/models/resource';
  import { get, computed } from '@ember/object';
  import { evaluate } from 'shared/utils/evaluate';
  import C from 'ui/utils/constants';
  import jsyaml from 'js-yaml';
  import flatMap from 'shared/utils/flat-map';
  import { isEmpty } from '@ember/utils';
  
  const { HELM_VERSION_2: helmV2, HELM_VERSION_3: helmV3 } = C.CATALOG;
  
  export default Resource.extend({
    scope: service(),
    intl:  service(),
  
    isHelm3: computed('helmVersion', function() {
      const { helmVersion = helmV2 } = this;
  
      if (helmVersion === helmV3) {
        return true;
      }
  
      return false;
    }),
  
    headers: computed('project.current.id', function() {
      return { [C.HEADER.PROJECT_ID]: get(this, 'scope.currentProject.id') };
    }),
  
    filesAsArray: computed('files', function() {
      var obj = (get(this, 'files') || {});
      var out = [];
  
      Object.keys(obj).forEach((key) => {
        out.push({
          name: key,
          body: obj[key]
        });
      });
  
      return out;
    }),
  
    allQuestions: computed('questions', function() {
      const out = [];
      const originQuestions = get(this, 'questions') || [];
  
      originQuestions.forEach((q) => {
        out.push(q);
        const subquestions = get(q, 'subquestions');
  
        if ( subquestions ) {
          subquestions.forEach((subq) => {
            if ( get(subq, 'showIf.length') > 0 ) {
              subq.showIf = `${ q.variable }=${ q.showSubquestionIf }&&${ subq.showIf }`;
            } else {
              subq.showIf = `${ q.variable }=${ q.showSubquestionIf }`;
            }
  
            if ( q.group ) {
              subq.group = q.group;
            }
          });
          out.pushObjects(subquestions);
        }
      });
  
      return out;
    }),
  
    validationErrors(answersMap) {
      const {
        intl, allQuestions, valuesYaml
      } = this;
  
      const filteredQuestions = allQuestions.filter((q) => evaluate(q, allQuestions));
      let errors              = [];
      let parsedYamlAnswers   = null;
  
      if (valuesYaml) {
        try {
          parsedYamlAnswers = jsyaml.safeLoad(valuesYaml);
        } catch ( err ) {
          return [err];
        }
  
        if (parsedYamlAnswers) {
          let flatParsed = flatMap(parsedYamlAnswers);
  
          Object.keys(flatParsed).forEach((fp) => {
            let questionMatch = filteredQuestions.findBy('variable', fp);
  
            if (questionMatch) {
              let answer = flatParsed[fp] || null;
  
              if ( questionMatch.required && questionMatch.type !== 'boolean' && isEmpty(answer) ) {
                errors.push(intl.t('validation.required', { key: questionMatch.label }));
              }
  
              if (answer) {
                validateLength(answer, questionMatch, questionMatch.label, intl, errors);
                validateChars(answer, questionMatch, questionMatch.label, intl, errors);
              }
            }
          });
        }
      } else {
        if ( filteredQuestions ) {
          filteredQuestions.forEach((item) => {
            if ( item.required && item.type !== 'boolean' && isEmpty(answersMap[item.variable]) ) {
              errors.push(intl.t('validation.required', { key: item.label }));
            }
  
            if ( item.answer ) {
              validateLength(item.answer, item, item.label, intl, errors);
              validateChars(item.answer, item, item.label, intl, errors);
            }
          });
        }
      }
  
  
      if ( errors.length > 0 ) {
        return errors;
      }
  
      errors = this._super(...arguments);
  
      return errors;
    },
  
  });
  