using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using CB.Entity;

namespace CB.Common
{
    public class TrendDataHelpers
    {
        public static string RemergeTrendHtmlData(string HtmlData, int start, int end)
        {
            if (string.IsNullOrEmpty(HtmlData))
                return null;

            string _htmlData = HtmlData;
            if (_htmlData.Contains("<tr>"))
                _htmlData = _htmlData.Substring(4, _htmlData.Length - 9); //去除tr标签
            var constSplit = "</td>";
            var htmlArr = _htmlData.Split(new string[] { constSplit }, StringSplitOptions.RemoveEmptyEntries);
            if (end == 0 || end >= htmlArr.Length)
                end = htmlArr.Length - 1;
            var sb = new StringBuilder();
            for (var i = start; i <= end; i++)
            {
                sb.Append(htmlArr[i] + constSplit);
            }
            return sb.ToString();
        }

        private static string[] ExtensionEmptyCol(int emptyCount)
        {
            if (emptyCount <= 0)
                return new string[0];

            var arr = new string[emptyCount];
            for (var i = 0; i < emptyCount; i++)
                arr[i] = "-1";

            return arr;
        }

        public static IEnumerable<TrendDataStatItem> ExtensionEmptyColMissStatData(string missStatData,
            int frontColCount, int behindColCount)
        {
            //var extmissStatData = string.Join(",", ExtensionEmptyCol(frontColCount)) + "," +
            //                      missStatData + "," +
            //                      string.Join(",", ExtensionEmptyCol(behindColCount));
            foreach (var _s in ExtensionEmptyCol(frontColCount))
            {
                yield return new TrendDataStatItem { Value = _s };
            }
            foreach (var _s in missStatData.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries))
            {
                if (_s == "-1") continue;
                yield return new TrendDataStatItem { Value = _s };
            }
            foreach (var _s in ExtensionEmptyCol(behindColCount))
            {
                yield return new TrendDataStatItem { Value = _s };
            }
        }

        public static IEnumerable<TrendDataStatItem> InsertEmptyColMissStatData(string missStatData, int startIndex,
            int colCount)
        {
            var _index = 0;
            foreach (var _s in missStatData.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries))
            {
                if (_s == "-1") continue;
                if (_index == startIndex)
                    foreach (var _s1 in ExtensionEmptyCol(colCount))
                        yield return new TrendDataStatItem { Value = _s1 };

                yield return new TrendDataStatItem { Value = _s };
                _index++;
            }
        }

        public static IEnumerable<TrendDataStatItem> ExtensionEmptyColMissStatData(int[] missStatData,
            int frontColCount, int behindColCount)
        {
            foreach (var _s in ExtensionEmptyCol(frontColCount))
            {
                yield return new TrendDataStatItem { Value = _s };
            }
            foreach (var _i in missStatData)
            {
                //if (_i == -1) continue;
                yield return new TrendDataStatItem { Value = _i.ToString() };
            }
            foreach (var _s in ExtensionEmptyCol(behindColCount))
            {
                yield return new TrendDataStatItem { Value = _s };
            }
        }

        public static IEnumerable<TrendDataStatItem> InsertEmptyColMissStatData(int[] missStatData, int startIndex,
            int colCount)
        {
            var _index = 0;
            foreach (var _i in missStatData)
            {
                if (_index == startIndex)
                    foreach (var _s1 in ExtensionEmptyCol(colCount))
                        yield return new TrendDataStatItem { Value = _s1 };

                yield return new TrendDataStatItem { Value = _i.ToString() };
                _index++;
            }
        }

        public static void SetModelStaticData(object obj)
        {
            var model = obj as TrendDataEntity<TrendChartData, TrendChartData>;
            if (model == null) return;
            var trendDataList = (List<TrendChartData>)model.TrendDataItems;
            var lastTData = trendDataList.LastOrDefault();
            model.MaxMissList = TrendDataHelpers.ExtensionEmptyColMissStatData(lastTData.AllMaxMiss.LastOrDefault(), 1, 0);
            model.AvgMissList = TrendDataHelpers.ExtensionEmptyColMissStatData(lastTData.AllAvgMiss.LastOrDefault(), 1, 0);
            model.AppearsList = TrendDataHelpers.ExtensionEmptyColMissStatData(lastTData.AllTimes.LastOrDefault(), 1, 0);
        }

        public static Tuple<int[], int[], int[]> LocalMissData(IList<TrendChartData> list)
        {
            if (list == null || list.Count <= 0)
                return Tuple.Create<int[], int[], int[]>(new int[0], new int[0], new int[0]);
            //将list按期号升序排列
            list = list.OrderBy(info => info.Term).ToList();

            //本期遗漏列表(当前页数据根据本期遗漏计算)
            List<List<int>> LocalMissArray = new List<List<int>>();

            #region 将list里面提取本期遗漏数据
            foreach (var item in list)
            {
                var row = new List<int>();
                for (int i = 0; i < item.LocalMiss.Count(); i++)
                {
                    if (item.LocalMiss[i] == "-1")
                    {
                        row.Add(-1);
                        continue;
                    }
                    foreach (var missvalue in item.LocalMiss[i].Split(','))
                    {
                        row.Add(missvalue.ToInt());
                    }
                }
                LocalMissArray.Add(row);
            }
            #endregion

            if (LocalMissArray.Count <= 0)
                return null;

            //当前页最大遗漏
            int[] maxMissArray = new int[LocalMissArray[0].Count];
            //当前页出现次数
            int[] TimesArray = new int[LocalMissArray[0].Count];
            //当前页遗漏总和
            int[] allMissArray = new int[LocalMissArray[0].Count];

            #region 根据当前页本期遗漏计算当前页（最大遗漏、出现次数、遗漏总和）
            for (int k = 0; k < LocalMissArray.Count; k++)
            {
                for (int i = 0; i < LocalMissArray[k].Count; i++)
                {
                    //如果为-1说明没有遗漏数据
                    if (LocalMissArray[k][i] == -1)
                    {
                        maxMissArray[i] = -1;
                        TimesArray[i] = -1;
                        allMissArray[i] = -1;
                        continue;
                    }
                    //遍历当前页遗漏找当前页最大遗漏
                    if (maxMissArray[i] < LocalMissArray[k][i])
                    {
                        maxMissArray[i] = LocalMissArray[k][i];
                    }
                    //遍历当前页遗漏累加当前页出现次数
                    if (LocalMissArray[k][i] == 0)
                    {
                        TimesArray[i]++;
                    }
                    //遍历当前页遗漏累加遗漏总数
                    if (k == 0)
                    {
                        allMissArray[i] = LocalMissArray[k][i];
                    }
                    else
                    {
                        if (LocalMissArray[k][i] != 0)
                        {
                            allMissArray[i]++;
                        }
                    }


                }
            }
            #endregion
            for (int i = 0; i < allMissArray.Length; i++)
            {
                if (allMissArray[i] != -1)
                {
                    var  f = TimesArray[i] >= 0 ? Math.Round((float)allMissArray[i] / ((float)TimesArray[i] + 1f), 0) : 0;
                    allMissArray[i] = f < 1 ? 1 : (int)f;
                }
            }
            return Tuple.Create<int[], int[], int[]>(maxMissArray, allMissArray, TimesArray);
        }

        public static int[] ChargeArrayPosition(int[] array, int start, int len1, int moveTo)
        {
            var count = array.Length;
            var sl = start + len1;
            if (count == 0)
                return array;
            if (moveTo < 0 || moveTo >= count)
                moveTo = count;
            if (start < 0 || sl > count)
                return array;

            var tmpArr = new int[len1];
            for (int i = start; i < sl; i++)
            {
                tmpArr[i - start] = array[i];
            }
            var newArr = new int[count];
            var _len = 0;
            for (int i = 0; i < count; i++)
            {
                if (i >= start && i < sl)
                {
                    _len++;
                    if (i != moveTo)
                        continue;
                }
                if (i == moveTo)
                {
                    i -= _len;
                    for (int j = 0; j < len1; j++)
                    {
                        newArr[i++] = tmpArr[j];
                        if (_len > 0)
                            _len--;
                    }
                    if (i >= count)
                        break;
                }
                newArr[i - _len] = array[i];
            }
            if (moveTo == count)
            {
                for (var i = 0; i < len1; i++)
                {
                    newArr[count - len1 + i] = tmpArr[i];
                }
            }
            return newArr;
        }

        public static int[] RemoveArray(int[] array, int start, int len)
        {
            var count = array.Length;
            if (count == 0)
                return array;
            var sl = start + len;
            if (start < 0 || sl > count)
                return array;

            var nlen = count - len;
            var newArr = new int[nlen];
            var _len = 0;
            for (var i = 0; i < count; i++)
            {
                if (i >= start && i < sl)
                {
                    _len++;
                    continue;
                }
                newArr[i - _len] = array[i];
            }
            return newArr;
        }

        public static int[] InsertToArray(int[] array, int start, int[] extArr)
        {
            var count = array.Length;
            if (count == 0 || extArr.Length == 0)
                return array;
            if (start < 0 || start > count)
                start = count;

            var len = extArr.Length;
            var nlen = count + len;
            var newArr = new int[nlen];
            var _len = 0;
            for (var i = 0; i < count; i++)
            {
                if (i == start)
                {
                    for (var j = 0; j < len; j++)
                    {
                        newArr[i + (_len++)] = extArr[j];
                    }
                }
                newArr[i + _len] = array[i];
            }
            if (start == count)
            {
                for (var i = count; i < nlen; i++)
                {
                    newArr[i] = extArr[i - count];
                }
            }
            return newArr;
        }
    }
}