define(['mUtil', "Component", "wev-loading", "fieldParseHelper", "mService", "pageExpandHelper"], function (mUtil, Component, WevLoading, fieldHelper, mService, pageExpandHelper) {
    var NLargeList = function (options) {
        var _list = {}, rowidMap = {}, $comp, $list, $errorTip, pageid;

        Component.super(this, options);

        this.type = "NLargeList";
        this.tpl = this.type + "_html";
        this.css = this.type + "_css";
        this.keysOfSkipedVarParse = ['dataSource', 'dataurl', 'showSet'];
        this.dataload = true;
        this.components = {
            loading: new WevLoading({
                delay: 300,
                animation: 1
            }),
            moreLoading: new WevLoading({
                btn: 1,
                onclick: function (hideLoading) {
                    _list.loadData(hideLoading);
                }
            })
        };

        var vm = this.viewModel = {
            dataSource: {
                type: 'mock'     //cube mock sql url api
            },
            pageStart: 1,
            pageSize: 10,
            showSet: {
                common: {
                    imgfield: "",
                    titlefield: "",
                    otherfields: []
                },
                cube: {
                    imgfield: {},
                    titlefield: {},
                    otherfields: []
                }
            },
            quickSearch: {
                hide: false,
                tip: "",
                fields: []
            },
            advancedSearch: {
                enable: false
            },
            btns: [],
            options: {
                readonly: false,
                showOnePage: false      //显示一页
            },
            relate: {},
            onload: function () { },
            standalone: true
        };
        
        this.beforeMount = function(){
            vm.pageStart = isNaN(vm.pageStart) ? 1 : vm.pageStart;
            //判断url是否包含变量
            vm.needReplaceUrl = mUtil.containsVariables(vm.options.dataurl);
            vm.isCube = vm.dataSource.type == 'cube';
            //过滤历史数据中静态页中的扩展按钮，改为动态获取
            if (vm.btns) {
                vm.btns = vm.btns.filter(function (ele) {
                    //历史数据无vm.pageExtend参数
                    if (ele.id.startsWith("pageexpandBtn")) vm.pageExtend = true;
                    return !ele.id.startsWith("pageexpandBtn");
                });
            }
        };
        
        this.mounted = function () {
            var that = this;
            pageid = this.pageid;
            $comp = this.$comp;
            $errorTip = this.$el.find(".wev-error");
            $list = $comp.find(".wev-table-view");

            // 初始化列表数据
            _list.refreshList(function () {
                mUtil.eval(vm.onload, that.pageid);
            });
            // 初始化搜索功能
            _list.initSearch();
            
            //初始化自定义按钮,切换显示按钮
            _list.initBtns(this.pageid);

            //绑定单条数据点击事件
            $comp.on("click.nav", "a.wev-navigate-right, .wev-file", function (e) {
                if($(e.target).closest('.wev-file[data-docid]').length) return;

                var $this = $(this);
                var item = util.getDataItem($this)||{};
                
                if (vm.options.readonly) return;
                
                if (vm.callback && mUtil.isFunction(vm.callback.click)) {
                    vm.callback.click.call(this, item);
                }
                if (vm.isCube && vm.relate.modeid != -1 && vm.options.urltype == 0){
                    if (vm.layoutUrl) return $u(vm.layoutUrl + "&billid=" + item.id);
                    Mobile_NS.getLayoutUrl(vm.relate.modeid, 1, item.id);
                }else if(item.dataurl){
                    var dataurl = item.dataurl;
                    if(item.dataurl.indexOf("javascript:") == -1){
                        $u(dataurl);
                    }else{
                        mUtil.eval(dataurl, that.pageid);
                    }
                }
            });
            // 解析布局url
            vm.isCube && vm.relate.modeid != -1 && !vm.options.readonly && vm.options.urltype === 0 && util.parseLayoutUrl();
        };
        
        this.reload = function (args, callback) {
            _list.state.dynamicParam = {};
            if (mUtil.isObject(args)) {
                $.extend(_list.state.dynamicParam, args);
            }
            _list.refreshList(callback);
        };
        
        _list.state = {
            timestamp: 0,
            pageNo: vm.pageStart - 1,
            currPage: 0,
            list: [],
            conditions: {},
            dynamicParam: {}
        };
        
        _list.initSearch = function () {
            var $search = $(".wev-search", $comp),
                $searchInput = $("input", $search);

            $search.on("click.active", ".wev-placeholder", function (e) {
                $search.addClass("wev-active").removeClass("wev-inactive");
                $searchInput.focus();
            }).on("click.clear", ".wev-clear-btn", function () {
                $searchInput.val("").focus().triggerHandler("input");
                _list.state.conditions = {};
            });
            // 搜索框事件
            $searchInput.on("blur", function () {
                if (this.value) return;

                $search.removeClass("wev-active").addClass("wev-inactive");
            }).on("input", function () {
                $search.toggleClass("wev-has-value", !!this.value);
            }).on("keyup", function (e) {
                if (e.keyCode !== 13) return;
                _list.state.conditions.searchKey = encodeURIComponent(this.value);
                _list.refreshList();
                this.blur();
            });
            
            if (!vm.isCube || !vm.advancedSearch.enable) return;
            // 高级搜索
            require(["css!listAdvancedSearch_css"]);
            
            var timestamp = new Date().valueOf(), pageid = this.pageid.split("_").slice(1).join("."), id = this.id;
            
            $search.on("click.advancedSearch", ".wev-search-advanced", function () {
                require(["mService"], function (mService) {
                    mService.show("search", {
                        _identity: id + "_" + timestamp,
                        pageid: pageid,
                        id: id,
                        searchid: vm.dataSource.searchid,
                        conditions: JSON.stringify(vm.advancedSearch.fields),
                        title: vm.advancedSearch.title
                    });
                });
            });
        };

        _list.initBtns = function () {
            var that = this;
            if (vm.pageExtend) {
                var cfg = {
                    pageid: pageid,
                    searchid: vm.dataSource.searchid
                };
                pageExpandHelper.parsePageExpand($comp.find(".wev-search"), that.id, cfg);
            }

            if (!vm.btns.length) return;

            $(".wev-list-btn-container", $comp).on("click", ".btn.wev-btn-custom", function () {
                var $btn = $(this);
                
                var index = $(this).data("index");

                mUtil.eval(vm.btns[index].click, pageid);
            });
        };

        _list.refreshList = function (cb) {
            var that = this;
            var coms = this.components;
            var loading = coms.loading,
                moreLoading = coms.moreLoading;
            var state = _list.state;

            state.pageNo = vm.pageStart - 1;
            state.currPage = 0;
            state.list = [];

            loading.setRefs(this.$comp, "wev-refreshing");
            loading.show();

            _list.loadData(function (hasMore, noData) {
                loading.hide();
                moreLoading.hide(hasMore, noData);
                cb && cb();
                mUtil.trigger('dataload', that.pageid, that.id);

                // 支持上拉刷新功能
                if(mUtil.canPullToRefresh(that.id) && hasMore) {
                    require(['pullToRefreshHelper'], function (PullToRefresh) {
                        var $container = $comp.closest('.page-content');

                        // 日历+列表的情况
                        if('auto' === $comp.css('overflow-y')) {
                            $container = $comp;
                        }

                        new PullToRefresh({
                            el: $list,
                            container: $container.get(0),
                            loadData: _list.loadData,
                            loading: that.components.moreLoading
                        });
                    });
                }
            });
        };

        _list.loadData = function (callback) {
            var that = this,
                state = _list.state,
                timestamp = new Date().valueOf(),
                sourceType = vm.dataSource.type,
                showView = vm.showSet[sourceType] || vm.showSet.common;
            
            state.timestamp = timestamp;
            state.pageNo++;
            state.currPage++;

            var currPageParam = mUtil.getPageParam(that.pageid) || {},
                defReqParam = $.extend({}, currPageParam,state.dynamicParam,state.conditions),
                searchKey = typeof(defReqParam.searchKey) != 'undefined' ? defReqParam.searchKey || "" : defReqParam.search_key || "",
                commonReqParam = {
                    pageNo: state.pageNo, 
                    pageSize: vm.pageSize, 
                    searchKey: searchKey
                },
                defInnerParam = $.extend({}, commonReqParam, {
                    PAGE_NO: state.pageNo, 
                    PAGE_SIZE: vm.pageSize, 
                    SEARCH_KEY: searchKey
                });
            
            commonReqParam = $.extend(defReqParam, commonReqParam);
            
            var showError = function(msg){
                callback(false, false);
                $errorTip.html(msg).show();
            };
            
            if(sourceType == 'cube'){
                if(!vm.dataSource.searchid){
                    showError(mUtil.getLabel(6112, "内容来源未配置，请联系管理员。"));
                    return;
                }
                //拓展请求参数
                var fieldparse = fieldHelper.parseFieldIds(JSON.stringify(showView));
                var requestParam = $.extend({}, commonReqParam, {
                    action: "getDatas", 
                    searchid: vm.dataSource.searchid, 
                    fieldparse: fieldparse,
                    searchFields: JSON.stringify(vm.quickSearch.fields || [])
                });
                var actionUrl = mUtil.getActionUrl(this.type, requestParam, this.pageid);
                mUtil.getJSON(actionUrl, function (result) {
                    result = result.data;
                    if (timestamp != state.timestamp) return;
                    
                    var convertResult = _list.convertShowDatas4CubeSearch(result, showView);
                    _list.renderData(convertResult.billDatas, convertResult.showDatas, result.totalSize, callback);
                }, showError);
            }else if(sourceType == 'mock'){
                var mockData = vm.dataSource.mockData;
                var requestParam = commonReqParam;
                var result;
                if(mUtil.isArray(mockData)){
                    var matchFields = JSON.stringify(showView).match(/\{(\w+)\}/g);
                    result = fieldHelper.convertFieldMockData(mockData, state.pageNo, vm.pageSize, decodeURIComponent(requestParam.searchKey || ""), matchFields);
                }
                if(result){
                    var convertResult = _list.convertShowDatas(result.datas.map(function(data){return data.dataMap}), showView);
                    _list.renderData(convertResult.billDatas, convertResult.showDatas, result.totalSize, callback);
                }else{
                    showError(mUtil.getLabel(6112, "内容来源未配置，请联系管理员。"));
                }
            }else if(sourceType == 'sql' && !vm.standalone){
                //拓展请求参数
                var requestParam = $.extend({}, commonReqParam, {
                    action: "getSqlDatas",
                    mec_id: that.id
                });
                
                var actionUrl = mUtil.getActionUrl(this.type, requestParam, this.pageid);
                
                mUtil.getJSON(actionUrl, function (result) {
                    result = result.data;
                    if (timestamp != state.timestamp) return;
                    
                    var convertResult = _list.convertShowDatas(result.datas, showView);
                    _list.renderData(convertResult.billDatas, convertResult.showDatas, result.totalSize, callback);
                }, showError);
            }else if(sourceType == 'url'){
                var urlConfig = vm.dataSource.urlConfig || {}, path = urlConfig.path || "";
                var sourceUrl = mUtil.replaceVal(path, defInnerParam);
                commonReqParam.searchKey = commonReqParam.searchKey ? decodeURIComponent(commonReqParam.searchKey) : "";
                var requestParam = commonReqParam;
                var formats = urlConfig.formats || {};
                require(["apiHelper"], function(apiHelper){
                    apiHelper.requestUrl(sourceUrl, formats, requestParam, function(result){
                        if (timestamp != state.timestamp) return;
                        
                        var totalSize = 0, datas;
                        if(formats.DATAS){
                            datas = mUtil.getKeyValue(formats.DATAS, result);
                            totalSize = formats.TOTAL_SIZE ? parseInt(mUtil.getKeyValue(formats.TOTAL_SIZE, result)) : datas.length;
                        }else{
                            datas = [{}];
                            totalSize = 1;
                        }
                        var convertResult = _list.convertShowDatas(datas, showView);
                        _list.renderData(convertResult.billDatas, convertResult.showDatas, totalSize, callback);
                    }, showError);
                });
            }else if(sourceType == 'api'){
                var apiConfig = vm.dataSource.apiConfig || {api: {},request: {},response: {}};
                defInnerParam.SEARCH_KEY = defInnerParam.SEARCH_KEY ? decodeURIComponent(defInnerParam.SEARCH_KEY) : "";
                //请求参数
                var requestParam = $.extend({}, commonReqParam, defInnerParam);
                require(["apiHelper"], function(apiHelper){
                    apiHelper.callApi(apiConfig, requestParam, function(result){
                        if (timestamp != state.timestamp) return;
                        
                        var formats = apiConfig.response.formats, totalSize = 0, datas;
                        if(formats.DATAS){
                            datas = mUtil.getKeyValue(formats.DATAS, result);
                            totalSize = formats.TOTAL_SIZE ? parseInt(mUtil.getKeyValue(formats.TOTAL_SIZE, result)) : datas.length;
                        }else{
                            datas = [{}];
                            totalSize = 1;
                        }
                        var convertResult = _list.convertShowDatas(datas, showView);
                        _list.renderData(convertResult.billDatas, convertResult.showDatas, totalSize, callback);
                    }, showError);
                });
            }else{
                showError(mUtil.getLabel(6113, '不支持的数据来源类型，请检查配置。'));
            }
        };
        
        _list.renderData = function(datas, showDatas, totalSize, callback){
            var that = this,
                state = _list.state;
            
            var currPage = state.currPage;
            var pageSize = vm.pageSize;
            
            mUtil.concat(state.list, datas);
            
            var templateHtml = [
                '{@each datas as d}',
                '<li data-id="${d.rowid}" class="wev-table-view-cell wev-media">',
                    '<a href="javascript:void(0);" class="wev-navigate-right{@if vm.options.readonly} wev-data-readonly"{@else}" data-ignoreviewimg{@/if}>',
                        '<div class="wev-table-checkbox"></div>',
                        '<div class="wev-media-object wev-pull-left">',
                            '$${d.imgFieldValue}',
                        '</div>',
                        '<div class="wev-media-body">',
                            '$${d.titleFieldValue}',
                            '{@each d.otherFieldValue as row}',
                            '<div class="wev-ellipsis">',
                                '$${row}',
                            '</div>',
                            '{@/each}',
                        '</div>',
                    '</a>',
                '</li>',
                '{@/each}'
            ].join('');

            var html = mUtil.parseTemplate(templateHtml, { datas: showDatas, vm: vm});
            var $newList = $(html);
            
            if (currPage == 1) {
                $list.html("");
            }

            $list.append($newList);

            mUtil.trigger("onpagechange", that.pageid, that.id, [state.pageNo , $newList]);

            util.initLazyImg();
            
            var totalPageCount = totalSize % pageSize === 0 ? totalSize / pageSize : parseInt(totalSize / pageSize) + 1;
            var hasMore = (currPage < totalPageCount) && !vm.options.showOnePage;
            var noData = totalSize <= 0;

            $errorTip.hide();
            callback(hasMore, noData);
            mUtil.renderVarParser(vm.needParseVar);
        };

        _list.convertShowDatas4CubeSearch = function(originDatas, viewset){
            var convertShowDataItem = function(billdata, fieldmap, fieldset){
                var imgfield = fieldset.imgfield, otherfields = fieldset.otherfields;
                //图片字段
                var imgDisplay = fieldHelper.isSettingValue(imgfield), imgFValue = '';
                imgDisplay && (imgFValue = fieldHelper.getFieldValue(imgfield, billdata, fieldmap, true, vm.options.readonly));
                //其他字段
                var otherFValue = [];
                if(mUtil.isArray(otherfields)){
                    otherfields.forEach(function(rowfields) {
                        var rowFieldValue = [];
                        rowfields.forEach(function(colfield) {
                            if(fieldHelper.isSettingValue(colfield)){
                                var colFieldValue = fieldHelper.getFieldValue(colfield, billdata, fieldmap, false, vm.options.readonly);
                                rowFieldValue.push('<div class="wev-col">'+colFieldValue+'</div>');
                            }
                        });
                        if(rowFieldValue.length > 0){
                            otherFValue.push(rowFieldValue.join(''));
                        }
                    });
                }

                var titleDisplay = fieldHelper.getFieldValue(fieldset.titlefield, billdata, fieldmap);

                return {
                    rowid           : billdata._rowid,
                    id              : billdata.keyvalue,
                    imgFieldValue   : imgFValue,
                    titleFieldValue : titleDisplay,
                    otherFieldValue : otherFValue
                };
            };
            var fieldmap = originDatas.fieldMap, listDatas = [], showDatas = [];
            
            originDatas.datas.forEach(function(data){
                var dataItem = $.extend({}, data.dataMap);
                var dataId = data.keyvalue;
                var dataurl = _list.parseDataUrl(data.dataMap, vm.options.dataurl, dataId);
                
                dataItem._rowid = data._rowid = mUtil.UUID();
                dataItem.id = dataId;
                dataItem.dataurl = dataurl;
                listDatas.push(dataItem);
                
                var showDataItem = convertShowDataItem(data, fieldmap, viewset);
                showDatas.push(showDataItem);
            });
            return {
                billDatas: listDatas,
                showDatas: showDatas
            };
        };
        
        _list.convertShowDatas = function(originDatas, viewset){
            return {
                billDatas: originDatas,
                showDatas: originDatas.map(function (d) {
                    d._rowid = mUtil.UUID();
                    d.dataurl = _list.parseDataUrl(d, vm.options.dataurl);
                    d = JSON.parse(Component.replaceMutilLanguage(JSON.stringify(d), mUtil.getUserLanguage()));
                    return {
                        rowid           : d._rowid,
                        imgFieldValue   : mUtil.replaceValAndVarParser(viewset.imgfield, fieldHelper.getFirstDataByFielddesc(viewset.imgfield,d)), // 图片
                        titleFieldValue : mUtil.replaceValAndVarParser(viewset.titlefield, d), // 标题
                        otherFieldValue : viewset.otherfields.map(function (field) {
                            return mUtil.replaceValAndVarParser(field, d);
                        }).filter(function (v) { return v; })
                    };
                })
            }
        };
        
        _list.parseDataUrl = function(billData, originUrl, billid){
            var dataurl = "",
                useCustomUrl = (vm.isCube && (vm.options.urltype == 1 || vm.relate.modeid == -1)) || !vm.isCube;
            if(useCustomUrl && originUrl){
                dataurl = vm.needReplaceUrl ? fieldHelper.replaceVal(originUrl, billData) : originUrl;
                if(dataurl.indexOf("javascript:") == -1 && vm.isCube){
                    if(!vm.options.isNewLayout && dataurl.indexOf("&billid=") == -1 && dataurl.indexOf("?billid=") == -1){
                        dataurl += (dataurl.indexOf("?") == -1 ? "?" : "&") + "billid=" + billid;
                    }
                }
            }else{
                dataurl = "javascript:void(0);";
            }
            return dataurl;
        };
        
        var util = {
            parseLayoutUrl: function() {
                var url = mUtil.getActionUrl("service.FormComponent", { action: "resolveDefaultLayout" });

                mUtil.getJSON(url, { modelid: vm.relate.modeid, appid: vm.relate.appid, uitype: 1 }, function (result) {
                    vm.layoutUrl = result.data || "";
                    require(["mApi/other"]);//TODO 预加载
                }, function (errMsg) { });
            },
            getDataItem: function ($el) {
                var _rowid = $el.closest("li.wev-table-view-cell").data("id"), rowData;
                _list.state.list.every(function(ele, i) {
                    if(_rowid === ele._rowid){
                        rowData = ele;
                        return false;
                    }
                    return true;
                });
                return rowData;
            },
            initLazyImg: function () {
                require(["lazyImgHelper"]);
            }
        };
        
        _list.initSearch = _list.initSearch.bind(this);
        _list.refreshList = _list.refreshList.bind(this);
        _list.loadData = _list.loadData.bind(this);
        _list.renderData = _list.renderData.bind(this);
        _list.convertShowDatas = _list.convertShowDatas.bind(this);
        _list.initBtns = _list.initBtns.bind(this);
    };

    return Component.init(NLargeList);
});