let model = {
    fields:{
        couponName: {
            type: 'string', // 数据库类型
            comment: '优惠券名称',
            // meta 可选 在生成表单，表格时可用来美好
            meta: {
                formType: 'input', // 可选 element ui 表单类型 输入，时间，开关等，默认 input
    
                isInline: false, // 可选，默认表单inline类型
                inputType: 'text', // 可选 ， HTML 原生类型 如 text password 等 默认 text
                placeholder: '' // 可选 表单提示文字
    
            },
            tableHidden: true
        },
        startTime: {
            type: 'date',
            comment: '发放时间',
            meta: {
                formType: 'date',
                placeholder: '请选择发放时间'
    
            }
        },
        product: {
            type: 'number',
            comment: '适用产品',
            meta: {
                formType: 'select',
                placeholder: '请选择适用产品',
                chineseMap: {
                    1: '全平台通用',
                    2: '城际客运',
                    3: '线路包车'
                }
            }
        },
        // 关联表的select
        roadLine: {
            type: 'string',
            comment: '适用线路',
            meta: {
                formType: 'select',
                isManySel: true, // 是否为多选，默认false
                chineseMap: {
                    useForeign: 'coupon_road' // 根据外键生成 select
                }
            }
        },
        userId: {
            type: 'number',
            comment: '添加人',
            meta: {
                formType: 'text', // 反例，外键字段必须为select字段
                inputType: 'hidden',
                chineseMap: {
                    useForeign: 'coupon_user'
                }
            }
        },
        disCount: {
            type: 'number',
            comment: '折扣',
            meta: {
                formType: 'inputNumber', // 计数器
                min: '',
                max: '',
                step: '',
                size: '',
                controlsPosition: 'right'
            }
        },
        status: {
            type: 'number',
            comment: '状态',
            meta: {
                formType: 'switch',
                activeText: '禁用',
                inactiveText: '启用',
                activeValue: 1,
                inactiveValue: 0
            }
        },
        cover: {
            type: 'string',
            comment: '封面',
            meta: {
                formType: 'image',// 图片组件
                uploadUrl: '' // 可选 ，默认使用系统的文件上传服务器 
            }
    
        },
        detail: {
            type: 'text',
            comment: '营销富文本详情',
            meta: {
                formType: 'richText',
                uploadUrl: '' // 富文本文件上传地址 
            }
        }
    },
    filters: {
        couponName: {
            label: '优惠券名称',
            type: 'text',
        },
        person: {
            label: '适用人群',
            type: {
                type: 'select',

                chineseMap: {
                    1: '男',
                    2: '女'
                }
            }
        },
        createTime: {
            label: '开始月份',
            type: 'date'
        },
        roadLine: {
            label: '请选择线路',
            type: {
                type: 'select',
                chineseMap: {
                    useForeign: 'coupon_road'
                }
            }
        },
        bTime: {
            label: '之间的日期',
            type:'doubleDate',
            //start:'startTime',
           // end:'endTime'
        }
    },
    foreign: {
        coupon_user: {
            key: 'user_id', // 当前模型的外键字段
            refer: 'id', // 关联表的字段
            referLabel: 'userName', // 关联表用于展示的字段，主要用于 table,form的展示
            onTable: 'user', // 关联的数据表
            foreignDesc: '外键描述'
        },
        coupon_road: {
            key: 'c_id', // 当前模型的外键字段
            refer: 'id', // 关联表的字段
            referLabel: 'userName', // 关联表用于展示的字段，主要用于 table,form的展示
            onTable: 'user', // 关联的数据表
            foreignDesc: '外键描述'
        },
    },
}

/**
 * 映射关系
 * input=>el-input
 * inputNumber=>el-input-number
 * switch=>el-switch 值必须为0或1
 * date=>el-date-picker
 * time=>el-time-select
 * image=>el-upload
 * select=>el-select
 * richText=>vue-qull-editor 富文本编辑器
 * rate=> <el-rate v-model="value1"></el-rate>
 */

/**
 * 还差哪些
 * 
 * 1.excel导出
 *
 * @param {*} fields 
 * @returns 
 */
function  makeTableColumn(fields) {
    let result = [];
    for (const item in fields) {
       result.push({
        label: fields[item].comment,
        prop: item,
        align: 'center',
        slot: item,
        flag: !Boolean(fields[item].tableHidden),
       })
    }
    result.push( {
        label: "操作",
        align: "center",
        slot: "action",
        width: "180",
        flag: true,
    })
    return JSON.stringify(result,null,4)
}

function makeFormCode(fields) {
    let result = ''
    for (const key in fields) {
        let meta = fields[key].meta
        let code = ''
        if (typeof meta == 'object' ) {
            switch (meta.formType) {
                case 'input':
                    code = `<el-input  v-model="mainFormData.${key}" placeholder="${meta.placeholder || ''}" />`
                    break;
                case 'inputNumber':
                    code = `<el-input-number v-model="mainFormData.${key}" :min="1" label="${meta.placeholder || ''}" />`
                    break;
                case 'switch':
                    code = `<el-switch  v-model="mainFormData.${key}" :active-value="1" :inactive-value="0" />`
                    break;
                case 'date':
                    code = `<el-date-picker v-model="mainFormData.${key}" type="date" placeholder="${meta.placeholder || ''}" />`
                    break;
                case 'time':
                    code = `<el-time-select v-model="mainFormData.${key}" placeholder="${meta.placeholder || ''}" />`
                    break;
                case 'rate':
                    code = `<el-rate v-model="mainFormData.${key}" />`
                    break;
                case 'image':
                    code = `<el-upload
                    class="avatar-uploader"
                    action="https://jsonplaceholder.typicode.com/posts/"
                    :show-file-list="false"
                    :on-success="handleAvatarSuccess"
                    :before-upload="beforeAvatarUpload">
                    <img v-if="imageUrl" :src="imageUrl" class="avatar">
                    <i v-else class="el-icon-plus avatar-uploader-icon"></i>
                  </el-upload>`
                   break;
                case 'select': 
                    code = `<el-select v-model="mainFormData.${key}" placeholder="${meta.placeholder || ''}">
                    <el-option
                      v-for="item in ${key}Options"
                      :key="item.value"
                      :label="item.label"
                      :value="item.value">
                    </el-option>
                  </el-select>`
                  break;
                case 'richText':
                    code = `<quill-editor v-model="mainFormData.${key}" ref="myQuillEditor" :options="editorOption" />`
                    break;
                default:
                    code = `<el-input  v-model="mainFormData.${key}" placeholder="${meta.placeholder || ''}" />`
                    break;
            }
            result+=`
            <el-form-item label="${fields[key].comment}" :label-width="formLabelWidth">
                ${code}
            </el-form-item>\n`;
            
        }

    }
    return result;

}

/**
 *
 * @param {*} fields 
 */
 function makeVueCode(model) {
    let fields = model.fields
    let filters = model.filters
    let primaryKey = model.primaryKey || 'id'
    let modelName = 'example'
    let result = {
        quoteCode:'', // vue 引用代码
        dataCode:'', // vue data 代码
        methodCode:'',// vue methods 代码
        createdLifeCode:'', // vue 生命周期 created代码
        filterFormCode:'', // vue 过滤表单代码
        tableSlotCode:'',
    }
    result.dataCode+=`modelName:${modelName},\nprimaryKey:${primaryKey},\n`
    let formCode = ''
    let searchForm = {  limit: 10, pg: 1, }
    for (const key in fields) {
        let meta = fields[key].meta
        // 查询是否有富文本功能，有就引用富文本代码
        if (meta && meta.formType.toLowerCase() == 'richtext') {}
        /**
         * 生成data代码
         * 1.外键映射属性
         * 2.过滤属性（searchForm）
         * 3.表格列属性 （mainTableColumns）
         * 
         */
        if (meta && meta.formType && meta.hasOwnProperty('chineseMap')) {
            // 外键引用要同时生成dataCode 和 methodsCode
            // 映射属性的命名规则是 key + Options
            if (meta.chineseMap.hasOwnProperty('useForeign')) {
                result.dataCode+=`${key}Options:[],\n`
                // 生成method代码 给Options动态赋值
                let foreign = model.foreign[meta.chineseMap.useForeign]
                if (!foreign) throw Error(`没有在模型【】的foreign属性找到对应的外键${meta.chineseMap.useForeign}`)
                console.log(`外键名称${foreign.key}`)
                result.methodCode+=`
                get${firstWordToUppercase(foreign.onTable)}(){
                    const { data } = await this.getJSON('/${foreign.onTable}/index')
                    if (data.length) {
                      this.${key}Options = data.map((item,index)=>{
                        return { value:item.${foreign.refer},label:item.${foreign.referLabel} }
                    })
                },\n`
                result.createdLifeCode+=`
                this.get${firstWordToUppercase(foreign.onTable)}()\n`
                
            }else {
                // 没有指定外键引用说明是本地写死，直接取即可
                let optionsCode = JSON.stringify(meta.chineseMap,null,4)
                result.dataCode+=`${key}Options:${optionsCode},\n`
            }
            // 如果有chineseMap 中文映射属性，生成对应的表格映射代码
            result.tableSlotCode+=`
            <template #${key}="scope"><el-link :underline="false" type="primary">{{${key}Options[scope.scope.row.${key}]}}</el-link></template>\n
            `    
        }
        switch (meta.formType) {
            case 'switch':
                result.tableSlotCode+=`
                <template #${key}="scope">
                <el-tag :type="scope.scope.row.${key} == ${fields[key].meta.activeValue} ? 'info' : 'danger' ">
                {{scope.scope.row.${key} == ${fields[key].meta.activeValue} ? '${fields[key].meta.activeText}' : '${fields[key].meta.inactiveText}'}}
                </el-tag>
                </template>\n`
                break;
            case 'date':
                result.tableSlotCode+=`<template #${key}="scope">getDate(scope.scope.row.${key})</template>\n`
                break;
            case 'image':
                result.tableSlotCode+=`<template #${key}="scope"><img :src="scope.scope.row.${key}" style="width:100%;height:100%" /></template>\n`
                break;
            default:
                break;
        }
    }
     // 搜索条件代码
    if (filters) {
        for (const item in filters) {
            console.log(item)
            // searchForm 初始化
            searchForm[item] = ''
           if (typeof filters[item].type == 'object') {
               // 外键或者映射查找需要生成其他选项
               let typeObj = filters[item].type
               if (typeObj.type == 'select' && typeObj.type.hasOwnProperty('chineseMap')) {
                    if (typeObj.type.chineseMap.hasOwnProperty('useForeign')) {
                        // result.dataCode+=`${key}Options:[],\n`
                    }else {
                        // 没有指定外键引用说明是本地写死，直接取即可
                        // let optionsCode = JSON.stringify(typeObj.type.chineseMap,null,4)
                        // result.dataCode+=`${key}Options:${optionsCode},\n`
                    }
               }
           }
           switch (filters[item].type) {
               case 'doubleDate':
                   // 日期之间的类型查找需要添加两个日期字段，
                    searchForm[filters[item].start || 'startTime'] = ''
                    searchForm[filters[item].end || 'endTime'] = ''
                    result.dataCode+=`startTimeFiled:'${filters[item].start || 'startTime'}', // 过滤条件开始时间字段\n`
                    result.dataCode+=`endTimeFiled: '${filters[item].end || 'endTime'}', // 过滤条件结束日期字段\n`
                    formCode = `
                <el-date-picker v-model="searchForm.${item}" type="datetimerange" 
                    start-placeholder="开始日期" 
                    end-placeholder="结束日期">
                </el-date-picker>\n`
                    break;
                case 'text':
                    formCode = `
                    <el-input  v-model="searchForm.${item}" placeholder="${filters[item].label || ''}" />\n
                    `
                    break;
                case 'select':
                    formCode = `
                    <el-select v-model="searchForm.${key}" placeholder="${filters[item].label || ''}">
                        <el-option
                          v-for="item in ${key}Options"
                          :key="item.value"
                          :label="item.label"
                          :value="item.value">
                        </el-option>
                      </el-select>\n
                    `
                case 'date':
                    formCode = `<el-date-picker v-model="searchForm.${item}" type="date" placeholder="${filters[item].label || ''}" />\n`
                    break;
                case 'time':
                    formCode = `<el-time-select v-model="searchForm.${item}" placeholder="${filters[item].label || ''}" />\n`
                    break;
                case 'rate':
                    formCode = `<el-rate v-model="searchForm.${item}" />\n`
                    break;
               default:
                   break;
           }
           result.filterFormCode+=`
        <el-form-item label="${filters[item].label}" :label-width="formLabelWidth">
            ${formCode}
        </el-form-item>\n`;
          
        
                
        }
        
    }
    result.dataCode+='searchForm:'+JSON.stringify(searchForm, null, 4)
    // 表格列代码
    result.dataCode+= ',mainTableColumn:'+makeTableColumn(fields)  
    /**
     * 生成method代码
     */

    return result;
} 

function firstWordToUppercase(str) {
    str = str.toLowerCase();
    var reg = /\b(\w)|\s(\w)/g; //  \b判断边界\s判断空格
    return str.replace(reg, function (m) {
        return m.toUpperCase()
    });
}





// makeViewRoute()
// console.log(makeVueCode(model))

