import {Zondy} from '../../service/common/Base';
import {ThemeSource} from './ThemeSource';
import {Theme as FeatureTheme} from '../../common/overlay/feature/Theme';
import {Point2D} from '../../service/common/Point2D';
import {FeatureSet} from '../../service/common/FeatureSet';
import {Rectangle} from '../../service/common/Rectangle';

/**
 * @class Zondy.Source.GraphThemeSource
 * @classdesc 统计专题图图层基类。
 * @param {string} chartsType - 图表类别。
 * @param {string} name - 图层名称。
 * @param {Object} options - 参数。
 * @param {ol.Map} options.map - 当前 Map 对象。
 * @param {string} options.chartsType - 图表类型。目前可用:"Bar","Bar3D","Line","Point","Pie","Ring"。
 * @param {Object} options.chartsSetting - 各类型图表的 chartsSetting 对象可设属性请参考具体图表模型类的注释中对 chartsSetting 对象可设属性的描述。chartsSetting 对象通常都具有以下几个基础可设属性。
 * @param {number} options.chartsSetting.width - 专题要素(图表)宽度。
 * @param {number} options.chartsSetting.height - 专题要素(图表)高度。
 * @param {Array.<number>} options.chartsSetting.codomain - 值域,长度为 2 的一维数组,第一个元素表示值域下限,第二个元素表示值域上限。
 * @param {number} [options.chartsSetting.XOffset] - 专题要素(图表)在 X 方向上的偏移值,单位像素。
 * @param {number} [options.chartsSetting.YOffset] - 专题要素(图表)在 Y 方向上的偏移值,单位像素。
 * @param {Array.<number>} [options.chartsSetting.dataViewBoxParameter] - 数据视图框 dataViewBox 参数,它是指图表框 chartBox(由图表位置、图表宽度、图表高度构成的图表范围框)在左、下,右,上四个方向上的内偏距值,长度为 4 的一维数组。
 * @param {number} [options.chartsSetting.decimalNumber] - 数据值数组 dataValues 元素值小数位数,数据的小数位处理参数,取值范围:[0, 16]。如果不设置此参数,在取数据值时不对数据做小数位处理。
 * @param {string} options.themeFields - 指定创建专题图字段。
 * @param {string} [options.id] - 专题图层 ID。
 * @param {number} [options.opacity = 1] - 图层透明度。
 * @param {string} [options.logo] - Logo。
 * @param {ol.proj.Projection} [options.projection] - {@link ol.proj.Projection} 投影信息。
 * @param {number} [options.ratio=1.5] - 视图比, 1 表示画布是地图视口的大小,2 表示地图视口的宽度和高度的两倍,依此类推。必须是 1 或更高。
 * @param {Array.<number>} [options.resolutions] - 分辨率数组。
 * @param {boolean} [options.isOverLay=true] - 是否进行压盖处理,如果设为 true,图表绘制过程中将隐藏对已在图层中绘制的图表产生压盖的图表。
 * @param {ol.source.State} [options.state] - 资源状态。
 * @extends {Zondy.Source.ThemeSource}
 */
class GraphThemeSource extends ThemeSource {

 constructor(name, chartsType, options) {
 super(name, options);
 this.chartsSetting = options.chartsSetting || {};
 this.themeFields = options.themeFields || null;
 this.overlayWeightField = options.overlayWeightField || null;
 this.isOverLay = options.isOverLay || true;
 this.charts = options.charts || [];
 this.cache = options.cache || {};
 this.chartsType = chartsType;
 this.options = {
 calGravity: options.calGravity || true
 }
 }

 /**
 * @function Zondy.Source.GraphThemeSource.prototype.destroy
 * @description 释放资源,将引用资源的属性置空。
 */
 destroy() {
 ThemeSource.prototype.destroy.apply(this, arguments);
 this.chartsType = null;
 this.chartsSetting = null;
 this.themeFields = null;
 this.overlayWeightField = null;
 this.isOverLay = null;
 this.options = {fitZoom: -1};
 this.charts = null;
 this.cache = null;
 }

 /**
 * @function Zondy.Source.GraphThemeSource.prototype.setChartsType
 * @description 设置图表类型,此函数可动态改变图表类型。在调用此函数前请通过 chartsSetting 为新类型的图表做相关配置。
 * @param {string} chartsType - 图表类型。目前可用:"Bar","Bar3D","Line","Point","Pie","Ring"。
 */
 setChartsType(chartsType) {
 this.chartsType = chartsType;
 this.redraw();
 }

 /**
 * @function Zondy.Source.GraphThemeSource.prototype.addFeatures
 * @description 向专题图图层中添加数据。
 * @param {Object} features - 待添加的要素。
 */
 addFeatures(features) {
 var me = this;
 this.dispatchEvent({
 type: 'beforefeaturesadded',
 value: {features: features}
 });
 if (features instanceof FeatureSet) {

 var attrs = null;

 var attstruct = features.AttStruct;
 var feaArr = features.SFEleArray;
 if (feaArr != null && feaArr.length > 0) {
 for (var j = 0; j < feaArr.length; j++) {
 var feature = feaArr[j];
 if (feature.AttValue != null && feature.AttValue.length > 0) {
 var attrs = {};
 for (var i = 0; i < feature.AttValue.length; i++) {
 attrs[(attstruct.FldName)[i]] = (feature.AttValue)[i];
 }
 attrs['FID'] = feature.FID;
 }
 feature.attributes = attrs;
 me.features.push(feature);
 }
 }
 }
 //绘制专题要素
 if (this.renderer) {
 this.changed();
 }
 }

 /**
 * @function Zondy.Source.GraphThemeSource.prototype.redrawThematicFeatures
 * @description 重绘所有专题要素。
 * 此方法包含绘制专题要素的所有步骤,包含用户数据到专题要素的转换,抽稀,缓存等步骤。
 * 地图漫游时调用此方法进行图层刷新。
 * @param {Object} extent - 重绘的范围。
 *
 */
 redrawThematicFeatures(extent) {
 //清除当前所有可视元素
 this.renderer.clearAll();
 var features = this.features;
 var bounds = new Rectangle(extent[0], extent[1], extent[2], extent[3]);

 for (var i = 0, len = features.length; i < len; i++) {
 var feature = features[i];
 // 要素范围判断
 var feaBounds = feature.bound;
 //剔除当前视图(地理)范围以外的数据
 if (bounds && !bounds.intersectsBounds(feaBounds)) {
 continue;
 }
 var cache = this.cache;
 // 用 feature id 做缓存标识
 var cacheField = feature.id;
 // 数据对应的图表是否已缓存,没缓存则重新创建图表
 if (cache[cacheField]) {
 continue;
 }
 cache[cacheField] = cacheField;
 var chart = this.createThematicFeature(feature);
 // 压盖处理权重值
 if (chart && this.overlayWeightField) {
 if (feature.attributes[this.overlayWeightField] && !isNaN(feature.attributes[this.overlayWeightField])) {
 chart["__overlayWeight"] = feature.attributes[this.overlayWeightField];
 }
 }
 if (chart) {
 this.charts.push(chart);
 }
 }
 this.drawCharts();
 }

 /**
 * @function Zondy.Source.GraphThemeSource.prototype.createThematicFeature
 * @description 向专题图图层中添加数据, 支持的 feature 类型为:iServer 返回的 feature JSON 对象。
 * @param {Object} feature - 待添加的要素。
 *
 */
 createThematicFeature(feature) {
 var thematicFeature;
 // 检查图表创建条件并创建图形
 if (FeatureTheme[this.chartsType] && this.themeFields && this.chartsSetting) {
 thematicFeature = new FeatureTheme[this.chartsType](feature, this, this.themeFields, this.chartsSetting, null, this.options);
 }
 // thematicFeature 是否创建成功
 if (!thematicFeature) {
 return false;
 }
 // 对专题要素执行图形装载
 thematicFeature.assembleShapes();
 return thematicFeature;
 }

 /**
 * @function Zondy.Source.GraphThemeSource.prototype.drawCharts
 * @description 绘制图表。包含压盖处理。
 *
 */
 drawCharts() {
 // 判断 rendere r就绪
 if (!this.renderer) {
 return;
 }
 var charts = this.charts;
 // 图表权重值处理
 if (this.overlayWeightField) {
 charts.sort(function (cs, ce) {
 if (typeof (cs["__overlayWeight"]) == "undefined" && typeof (ce["__overlayWeight"]) == "undefined") {
 return 0;
 } else if (typeof (cs["__overlayWeight"]) != "undefined" && typeof (ce["__overlayWeight"]) == "undefined") {
 return -1;
 } else if (typeof (cs["__overlayWeight"]) == "undefined" && typeof (ce["__overlayWeight"]) != "undefined") {
 return 1;
 } else if (typeof (cs["__overlayWeight"]) != "undefined" && typeof (ce["__overlayWeight"]) != "undefined") {
 if (parseFloat(cs["__overlayWeight"]) < parseFloat(ce["__overlayWeight"])) {
 return 1;
 } else {
 return -1;
 }
 }
 return 0;
 });
 }
 // 不进行避让
 if (!this.isOverLay) {
 for (var m = 0, len_m = charts.length; m < len_m; m++) {
 var chart_m = charts[m];
 // 图形参考位置 (reSetLocation 会更新 chartBounds)
 var shapeROP_m = chart_m.resetLocation();
 // 添加图形
 var shapes_m = chart_m.shapes;
 for (var n = 0, slen_n = shapes_m.length; n < slen_n; n++) {
 shapes_m[n].refOriginalPosition = shapeROP_m;
 this.renderer.addShape(shapes_m[n]);
 }
 }
 } else {
 // 压盖判断所需 chartsBounds 集合
 var chartsBounds = [];
 var mapBounds = this.map.getView().calculateExtent();
 // 获取地图像素 bounds
 var mapPxLT = this.getLocalXY([mapBounds[0], mapBounds[3]]);
 var mapPxRB = this.getLocalXY([mapBounds[2], mapBounds[1]]);
 var mBounds = new Rectangle();
 mBounds.xmin = Math.min(parseFloat(mapPxLT[0]), parseFloat(mapPxRB[0]));
 mBounds.xmax = Math.max(parseFloat(mapPxLT[0]), parseFloat(mapPxRB[0]));
 mBounds.ymin = Math.min(parseFloat(mapPxLT[1]), parseFloat(mapPxRB[1]));
 mBounds.ymax = Math.max(parseFloat(mapPxLT[1]), parseFloat(mapPxRB[1]));
 // 压盖处理 & 添加图形
 for (var i = 0, len = charts.length; i < len; i++) {
 var chart = charts[i];
 // 图形参考位置 (reSetLocation 会更新 chartBounds)
 var shapeROP = chart.resetLocation();
 // 图表框
 var cbs = chart.chartBounds;
 var cBounds = [{
 "x": cbs.xmin,
 "y": cbs.ymin
 }, {
 "x": cbs.xmin,
 "y": cbs.ymax
 }, {
 "x": cbs.xmax,
 "y": cbs.ymax
 }, {
 "x": cbs.xmax,
 "y": cbs.ymin
 }, {
 "x": cbs.xmin,
 "y": cbs.ymin
 }];
 // 地图范围外不绘制
 if (mBounds) {
 if (!this.isChartInMap(mBounds, cBounds)) {
 continue;
 }
 }
 // 是否压盖
 var isOL = false;
 if (i !== 0) {
 for (let j = 0; j < chartsBounds.length; j++) {
 //压盖判断
 if (this.isQuadrilateralOverLap(cBounds, chartsBounds[j])) {
 isOL = true;
 break;
 }
 }
 }
 if (isOL) {
 continue;
 } else {
 chartsBounds.push(cBounds);
 }
 // 添加图形
 var shapes = chart.shapes;
 for (let j = 0, slen = shapes.length; j < slen; j++) {
 shapes[j].refOriginalPosition = shapeROP;
 this.renderer.addShape(shapes[j]);
 }
 }
 }
 // 绘制图形
 this.renderer.render();
 }

 /**
 * @function Zondy.Source.GraphThemeSource.prototype.getShapesByFeatureID
 * @description 通过 FeatureID 获取 feature 关联的所有图形。如果不传入此参数,函数将返回所有图形。
 * @param {number} featureID - 要素 ID。
 */
 getShapesByFeatureID(featureID) {
 var list = [];
 var shapeList = this.renderer.getAllShapes();
 if (!featureID) {
 return shapeList
 }
 for (var i = 0, len = shapeList.length; i < len; i++) {
 var si = shapeList[i];
 if (si.refDataID && featureID === si.refDataID) {
 list.push(si);
 }
 }
 return list;
 }

 /**
 * @function Zondy.Source.GraphThemeSource.isQuadrilateralOverLap
 * @description 判断两个四边形是否有压盖。
 * @param {Array.<Object>} quadrilateral - 四边形节点数组。
 * @param {Array.<Object>} quadrilateral2 - 第二个四边形节点数组。
 */
 isQuadrilateralOverLap(quadrilateral, quadrilateral2) {
 var quadLen = quadrilateral.length,
 quad2Len = quadrilateral2.length;
 if (quadLen !== 5 || quad2Len !== 5) {
 return null;
 } //不是四边形

 var OverLap = false;
 //如果两四边形互不包含对方的节点,则两个四边形不相交
 for (let i = 0; i < quadLen; i++) {
 if (this.isPointInPoly(quadrilateral[i], quadrilateral2)) {
 OverLap = true;
 break;
 }
 }
 for (let i = 0; i < quad2Len; i++) {
 if (this.isPointInPoly(quadrilateral2[i], quadrilateral)) {
 OverLap = true;
 break;
 }
 }
 //加上两矩形十字相交的情况
 for (let i = 0; i < quadLen - 1; i++) {
 if (OverLap) {
 break;
 }
 for (let j = 0; j < quad2Len - 1; j++) {
 var isLineIn = this.lineIntersection(quadrilateral[i], quadrilateral[i + 1], quadrilateral2[j], quadrilateral2[j + 1]);
 if (isLineIn.CLASS_NAME === "Zondy.Object.Point2D") {
 OverLap = true;
 break;
 }
 }
 }
 return OverLap;
 }

 /**
 * @function Zondy.Source.GraphThemeSource.prototype.lineIntersection
 * @description 判断两条线段是不是有交点。
 * @param a1 - {Zondy.Geometry.Point} 第一条线段的起始节点。
 * @param a2 - {Zondy.Geometry.Point} 第一条线段的结束节点。
 * @param b1 - {Zondy.Geometry.Point} 第二条线段的起始节点。
 * @param b2 - {Zondy.Geometry.Point} 第二条线段的结束节点。
 * @return {Object} 如果相交返回交点,如果不相交返回两条线段的位置关系。
 */
 lineIntersection(a1, a2, b1, b2) {
 var intersectValue = null;
 var k1;
 var k2;
 var b = (b2.x - b1.x) * (a1.y - b1.y) - (b2.y - b1.y) * (a1.x - b1.x);
 var a = (a2.x - a1.x) * (a1.y - b1.y) - (a2.y - a1.y) * (a1.x - b1.x);
 var ab = (b2.y - b1.y) * (a2.x - a1.x) - (b2.x - b1.x) * (a2.y - a1.y);
 //ab==0代表两条线断的斜率一样
 if (ab !== 0) {
 k1 = b / ab;
 k2 = a / ab;

 if (k1 >= 0 && k2 <= 1 && k1 <= 1 && k2 >= 0) {
 intersectValue = new Point2D(a1.x + k1 * (a2.x - a1.x), a1.y + k1 * (a2.y - a1.y));
 } else {
 intersectValue = "No Intersection";
 }
 } else {

 if (b === 0 && a === 0) {
 var maxy = Math.max(a1.y, a2.y);
 var miny = Math.min(a1.y, a2.y);
 var maxx = Math.max(a1.x, a2.x);
 var minx = Math.min(a1.x, a2.x);
 if (((b1.y >= miny && b1.y <= maxy) || (b2.y >= miny && b2.y <= maxy)) &&
 (b1.x >= minx && b1.x <= maxx) || (b2.x >= minx && b2.x <= maxx)) {
 intersectValue = "Coincident";//重合
 } else {
 intersectValue = "Parallel";//平行
 }

 } else {
 intersectValue = "Parallel";//平行
 }
 }
 return intersectValue;
 }

 /**
 * @function Zondy.Source.GraphThemeSource.prototype.isPointInPoly
 * @description 判断一个点是否在多边形里面。(射线法)。
 * @param {Object} pt - 需要判定的点对象,该对象含有属性 x(横坐标),属性 y(纵坐标)。
 * @param {Array.<Object>} poly - 多边形节点数组。
 */
 isPointInPoly(pt, poly) {
 for (var isIn = false, i = -1, l = poly.length, j = l - 1; ++i < l; j = i) {
 ((poly[i].y <= pt.y && pt.y < poly[j].y) || (poly[j].y <= pt.y && pt.y < poly[i].y)) &&
 (pt.x < (poly[j].x - poly[i].x) * (pt.y - poly[i].y) / (poly[j].y - poly[i].y) + poly[i].x) &&
 (isIn = !isIn);
 }
 return isIn;
 }

 /**
 * @function Zondy.Source.GraphThemeSource.prototype.isChartInMap
 * @description 判断图表是否在地图里。
 * @param {Zondy.Bounds} mapPxBounds - 地图像素范围。
 * @param {Array.<Object>} chartPxBounds - 图表范围的四边形节点数组。
 */
 isChartInMap(mapPxBounds, chartPxBounds) {
 var mb = mapPxBounds;
 var isIn = false;
 for (var i = 0, len = chartPxBounds.length; i < len; i++) {
 var cb = chartPxBounds[i];

 if (cb.x >= mb.xmin && cb.x <= mb.xmax && cb.y >= mb.ymin && cb.y <= mb.ymax) {
 isIn = true;
 break;
 }
 }
 return isIn;
 }

 /**
 * @function Zondy.Source.GraphThemeSource.prototype.clearCache
 * @description 清除缓存。
 */
 clearCache() {
 this.cache = {};
 this.charts = [];
 }

 /**
 * @function Zondy.Source.GraphThemeSource.prototype.removeFeatures
 * @description 从专题图中删除 feature。这个函数删除所有传递进来的矢量要素。参数中的 features 数组中的每一项,必须是已经添加到当前图层中的 feature。
 * @param {Zondy.Feature.Vector} features - 要删除的要素。
 */
 removeFeatures(features) {
 this.clearCache();
 super.removeFeatures(features);
 }

 /**
 * @function Zondy.Source.GraphThemeSource.prototype.removeAllFeatures
 * @description 移除所有的要素
 */
 removeAllFeatures() {
 this.clearCache();
 super.removeAllFeatures();
 }

 /**
 * @function Zondy.Source.GraphThemeSource.prototype.redraw
 * @description 重绘该图层
 */
 redraw() {
 this.clearCache();
 if (this.renderer) {
 this.redrawThematicFeatures(this.map.getView().calculateExtent());
 return true;
 }
 return false
 }

 /**
 * @function Zondy.Source.GraphThemeSource.prototype.clear
 * @description 清除的内容包括数据(features) 、专题要素、缓存。
 */
 clear() {
 if (this.renderer) {
 this.renderer.clearAll();
 this.renderer.refresh();
 }
 this.removeAllFeatures();
 this.clearCache();
 }

 canvasFunctionInternal_(extent, resolution, pixelRatio, size, projection) { // eslint-disable-line no-unused-vars
 return ThemeSource.prototype.canvasFunctionInternal_.apply(this, arguments);
 }
}

export {GraphThemeSource};
Zondy.Source.GraphThemeSource = GraphThemeSource;