import Vue from 'vue'
import { mergeRecursive } from "./../utils/ruoyi";
import DictMeta from './DictMeta'
import DictData from './DictData'
import { getDicts as getDicts } from './../api/InventoryManagement';
import request from './../utils/request';


const DEFAULT_DICT_OPTIONS = {
  types: [],
}

/**
 * @classdesc 字典
 * @property {Object} label 标签对象，内部属性名为字典类型名称
 * @property {Object} dict 字段数组，内部属性名为字典类型名称
 * @property {Array.<DictMeta>} _dictMetas 字典元数据数组
 */
export default class Dict {
  constructor(props) {
    this.owner = null
    this.label = {}
    this.type = {}
    this.raw={}
    if(props){
      this.apiurl=props;
    }else{
      this.apiurl="/api/sysdict/get_dict";
    } 
  } 
  init(options) {
    return new Promise((r)=>{
     let params=Object.assign([],options);
    if (options instanceof Array) {
      options = { types: options }
    }
    const opts = mergeRecursive(DEFAULT_DICT_OPTIONS, options) 
    
    if (opts.types === undefined) {
      r();
      throw new Error('need dict types')
    }  
    getRequest(params,this.apiurl).then((res)=>{
      if(res&&res.datas){
        const response=res.datas;
        sessionStorage.setItem("dictdata",JSON.stringify(response));
        Object.keys(response).map((k,i)=>{

          let dictMeta=DictMeta.parse(k)  
          const type = dictMeta.type  

          Vue.set(this.label, type, {})
          Vue.set(this.type, type, [])
          Vue.set(this.raw, type, [])
          if (dictMeta.lazy) {
            return
          }
          let dicts = dictMeta.responseConverter(response, dictMeta)
          if (!(dicts instanceof Array)) {
            console.error('the return of responseConverter must be Array.<DictData>')
            dicts = []
           } else if (dicts.filter(d => d instanceof DictData).length !== dicts.length) {
             console.error('the type of elements in dicts must be DictData')
             dicts = []
           }
          this.type[type].splice(0, Number.MAX_SAFE_INTEGER, ...dicts) ;
         let newraw=[];
            dicts.forEach(d => {  
              newraw.push(d.raw);
              Vue.set(this.label[type], d.value, d.label); 
            });    
           Vue.set(this.raw, type, newraw);
           if(Object.keys(response).length-1==i){
            r();
           } 
        });
      } 
     });
    });
  }

  
 
  getDict(name){
    return new Promise((r)=>{
      let options=Array.isArray(name)?name:[name];
      let params=Object.assign([],options);
      if (options instanceof Array) {
        options = { types: options }
      }
      const opts = mergeRecursive(DEFAULT_DICT_OPTIONS, options) 
      
      if (opts.types === undefined) {
        r();
        throw new Error('need dict types')
      } 

      getRequest(params,this.apiurl).then((res)=>{
        if(res&&res.datas){
          const response=res.datas; 
          Object.keys(response).map((k,i)=>{
            let dictMeta=DictMeta.parse(k) 
            const type = dictMeta.type 
            Vue.set(this.label, type, {})
            Vue.set(this.type, type, [])
            Vue.set(this.raw, type, [])
            if (dictMeta.lazy) {
              return
            }
            let dicts = dictMeta.responseConverter(response, dictMeta)
            if (!(dicts instanceof Array)) {
              console.error('the return of responseConverter must be Array.<DictData>')
              dicts = []
             } else if (dicts.filter(d => d instanceof DictData).length !== dicts.length) {
               console.error('the type of elements in dicts must be DictData')
               dicts = []
             } 
            this.type[type].splice(0, Number.MAX_SAFE_INTEGER, ...dicts)
            let newraw=[];
              dicts.forEach(d => {
                newraw.push(d.raw);
                Vue.set(this.label[type], d.value, d.label)
              });
            
              Vue.set(this.raw, type, newraw);
              if(Object.keys(response).length-1==i){
                r(dicts);
              } 
          });
        } 
       });
      });
  }

  doSession(response){
    return new Promise((r)=>{
      Object.keys(response).map((k,i)=>{
        let dictMeta=DictMeta.parse(k) 
        const type = dictMeta.type
        Vue.set(this.label, type, {})
        Vue.set(this.type, type, [])
        Vue.set(this.raw, type, [])
        if (dictMeta.lazy) {
          return
        }
        let dicts = dictMeta.responseConverter(response, dictMeta)
        if (!(dicts instanceof Array)) {
          console.error('the return of responseConverter must be Array.<DictData>')
          dicts = []
         } else if (dicts.filter(d => d instanceof DictData).length !== dicts.length) {
           console.error('the type of elements in dicts must be DictData')
           dicts = []
         }
        this.type[type].splice(0, Number.MAX_SAFE_INTEGER, ...dicts);
        let newraw=[];
          dicts.forEach(d => {
            newraw.push(d.raw);
            Vue.set(this.label[type], d.value, d.label);
          });
          Vue.set(this.raw, type, newraw);
          if(Object.keys(response).length-1==i){
            r();
          }
      });
    }); 
  }
  /**
   * 重新加载字典
   * @param {String} type 字典类型
   */
  reloadDict(type) {
    const dictMeta = this._dictMetas.find(e => e.type === type)
    if (dictMeta === undefined) {
      return Promise.reject(`the dict meta of ${type} was not found`)
    }
    return loadDict(this, dictMeta)
  }
}


function getRequest(options,apiurl) {  
    return request({
      url: apiurl||"/api/sysdict/get_dict",
      method: 'post',
      data: {dict_code:Array.isArray(options)?options:[options]}
    });
  }



/**
 * 加载字典
 * @param {Dict} dict 字典
 * @param {DictMeta} dictMeta 字典元数据
 * @returns {Promise}
 */
function loadDict(dict, dictMeta) {
  return dictMeta.request(dictMeta)
    .then(response => {
      const type = dictMeta.type

      let dicts = dictMeta.responseConverter(response, dictMeta)
      if (!(dicts instanceof Array)) {
        console.error('the return of responseConverter must be Array.<DictData>')
        dicts = []
      } else if (dicts.filter(d => d instanceof DictData).length !== dicts.length) {
        console.error('the type of elements in dicts must be DictData')
        dicts = []
      }
      dict.type[type].splice(0, Number.MAX_SAFE_INTEGER, ...dicts)
      dicts.forEach(d => {
        Vue.set(dict.label[type], d.value, d.label)
      })
      return dicts
    })
}