using DocumentFormat.OpenXml;
using DocumentFormat.OpenXml.Drawing;
using DocumentFormat.OpenXml.Drawing.Charts;
using DocumentFormat.OpenXml.Packaging;
using DocumentFormat.OpenXml.Presentation;
using HTEXLib.Helpers.ShapeHelpers;
using HTEXLib.Models.Inner;
using System;
using System.Collections.Generic;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Xml.Linq;

namespace HTEXLib.Models.HTEX
{
    public class HtexChart : HtexElement
    {
        public HtexChart(string id, double rot, double width, double height,
                                   double top, double left, bool invisible,
                                   bool animatable, int index, DocumentFormat.OpenXml.Drawing.Charts.ChartReference Chart, PPTSlide slide, string partForm)
        {
            base.slide = slide;
            this.rot = rot;
            this.Chart = Chart;
            base.id = id;
            base.top = top;
            base.left = left;
            base.width = width;
            base.height = height;
            base.invisible = invisible;
            base.animatable = animatable;
            base.index = index;
            base.type = "Chart";
            base.partForm = partForm;
        }
        public ChartPart chartPart { get; set; }
        public  string VerticalAlign { get; set; }
        public DocumentFormat.OpenXml.Drawing.Charts.ChartReference Chart { get; set; }
        public override List<Item> DrawElement()
        {
            var ChartNode = slide.SlidePart.Parts.Where(x => x.RelationshipId == Chart.Id).FirstOrDefault();
            var url = ChartNode.OpenXmlPart.Uri.ToString().Replace("../", "/ppt/");
            var ChartParts = slide.SlidePart.GetPartsOfType<DocumentFormat.OpenXml.Packaging.ChartPart>();
            if (ChartParts != null) {
                var chart = ChartParts.Where(x => x.Uri.ToString() == url).FirstOrDefault() ;
                chartPart = chart;
                if (chart != null) {
                    ChartColorStylePart ChartColorStylePart = null;
                    ChartStylePart ChartStylePart = null;
                    foreach (var idp in chart.Parts) {
                        if (idp.OpenXmlPart is ChartColorStylePart ChartColorStyleParts) {
                            ChartColorStylePart = ChartColorStyleParts;
                        }
                        if (idp.OpenXmlPart is ChartStylePart ChartStyleParts)
                        {
                            ChartStylePart = ChartStyleParts;
                        }
                    }

                    if (ChartStylePart != null) {
                        var ChartStyleChildren = ChartStylePart.ChartStyle.ChildElements;
                        foreach (var child in ChartStyleChildren)
                        {
                            if (child is DocumentFormat.OpenXml.Office2013.Drawing.ChartStyle.StyleEntry StyleEntry)
                            {

                                DoStyleEntry(StyleEntry);
                            }
                            ///OfficeArtExtensionList   cs: extLst
                            // MarkerLayoutProperties    cs: dataPointMarkerLayout

                        }
                    }
                   
                    Chart charts= DrawChart(chart.ChartSpace);
                    return new List<Item> { charts };
                }
            }
            return null; 
        }

        public Chart DrawChart(DocumentFormat.OpenXml.Drawing.Charts.ChartSpace chartSpace) {
            var Chart = chartSpace.GetFirstChild<DocumentFormat.OpenXml.Drawing.Charts.Chart>();
            var ShapeProperties = chartSpace.GetFirstChild<DocumentFormat.OpenXml.Drawing.Charts.ShapeProperties>();
            HTEXLib.Models.HTEX.ShapeStyle shapeStyleChart= PPTXHelper.DoShapeProperties(ShapeProperties,slide,type,partForm);
            var TextProperties = chartSpace.GetFirstChild<TextProperties>();
            var style = chartSpace.GetFirstChild<DocumentFormat.OpenXml.Drawing.Charts.Style>();
            var ColorMapOverride = chartSpace.GetFirstChild<DocumentFormat.OpenXml.Drawing.Charts.ColorMapOverride>();
            var style2010 = chartSpace.GetFirstChild<DocumentFormat.OpenXml.Office2010.Drawing.Charts.Style>();
            var UserShapesReference = chartSpace.GetFirstChild<UserShapesReference>();
            var charts = DoPlotArea(Chart.PlotArea);
            ShapeStyle shapeStyle = null;
            if (Chart.Title != null)
            {
                var ChartShapeProperties = Chart.Title.ChartShapeProperties;
                shapeStyle = PPTXHelper.DoShapeProperties(ChartShapeProperties, slide, type, partForm, chartPart);
            }
            LinkedList<PPTParagraph> PPTParagraphs=  DoChartTitle(Chart.Title);
            List<Paragraph> paragraphs = DrawText(PPTParagraphs);
            Shape shape= new Shape { type = "Shape", shapeType = "Rect", paragraph = paragraphs };
            shape.style.fill = shapeStyle != null ? shapeStyle.fill : null;
            shape.style.border = shapeStyle != null ? shapeStyle.border : null;
            var  chart= new Chart { id = this.id,  charts =charts,title=shape};
            Position position = new Position { cx = width, cy = height, x = left, y = top, rot = rot };
            chart.style.position = position;
            chart.style.fill = shapeStyleChart != null ? shapeStyleChart.fill : null;
            chart.style.border = shapeStyleChart != null ? shapeStyleChart.border : null;
            return chart;
        }
        public LinkedList<PPTParagraph> DoChartTitle(DocumentFormat.OpenXml.Drawing.Charts.Title title)
        {
            if (title==null  ||title.ChartText == null)
            {
                return null;
            }
            LinkedList<PPTParagraph> Texts = new LinkedList<PPTParagraph>();
            var BodyProperties = title.ChartText.RichText.BodyProperties;
            
            var ListStyle = title.ChartText.RichText.ListStyle;

            var Layout = title.Layout;
          
            if (BodyProperties == null)
            {
                BodyProperties = title.TextProperties.BodyProperties;

            }
            if (ListStyle != null&& title.TextProperties!=null)
            {
                ListStyle = title.TextProperties.ListStyle;
            }
            if (ListStyle != null)
            {
                //TODO文本层级内容
            }
            if (BodyProperties.Anchor != null)
            {
                string VerticalAlign = BodyProperties.Anchor.Value.ToString();
            }

            int fontScale = 100000;
            if (BodyProperties.GetFirstChild<NormalAutoFit>() != null &&
                    BodyProperties.GetFirstChild<NormalAutoFit>().FontScale != null)
            {
                fontScale = BodyProperties.GetFirstChild<NormalAutoFit>().FontScale.Value;
            }
            var ExtensionList = title.ExtensionList;
            var Paragraphs = title.ChartText.RichText.Elements<DocumentFormat.OpenXml.Drawing.Paragraph>();
            foreach (var paragraph in Paragraphs)
            {
                PlaceholderShape placeholder = null;
                var par = new PPTParagraph(slide, placeholder,partForm)
                {
                    Paragraph = index++
                };
                if (paragraph.ParagraphProperties != null)
                {
                    int level = paragraph.ParagraphProperties.Level == null ?
                               -1 : paragraph.ParagraphProperties.Level.Value;

                    par.Level = level;
                }
                par.SetParagraphProperties(paragraph, slide.SlidePart,
                                        slide.shapeListStyleMaster, slide.shapeListStyleLayout);
                bool hasText = false;
                foreach (var obj in paragraph.ChildElements)
                {
                    hasText = GetParagraphChildElements(title.ChartText.RichText, par, hasText, obj, fontScale);
                }
                //This is because when we set paragraph properties we add the bullet to the text runs.
                //If we don't have text it still outputs the bullet character. 
                if (par.bullet != null && hasText)
                {
                    par.RunPropList.Insert(0, par.bullet);
                }
                Texts.AddLast(par);
            }
            return Texts;
        }
        public List<Paragraph> DrawText(LinkedList<PPTParagraph> Texts)
        {
            if (Texts == null) {
                return null;
            }
            List<Paragraph> Paragraphs = new List<Paragraph>();
            foreach (var par in Texts)
            {
                double paragraphTop = par.getSpaceBeforePoints();
                Paragraph paragraph = new HTEXLib.Paragraph { animatable = par.Animatable, invisible = par.Invisible };
               
                paragraph.style.hori = par.Align;
                paragraph.style.vert = VerticalAlign;
                if (par.bullet != null)
                {
                    var bullet = par.bullet;
                    paragraph.buChar = new BuChar
                    {
                        type=bullet.BulletType,
                        left = bullet.Left,
                        buchar = bullet.Text,
                        color = bullet.FontColor,
                        typeface = bullet.FontFamily,
                        size = bullet.FontSize,

                    };
                }
                int newTop = par.getSpaceBeforePoints();
                int left = 0;
                List<HtexText> textElements = new List<HtexText>();
                List<Text> texts = new List<Text>();
                if (par.RunPropList == null || par.RunPropList.Count == 0 && par.defaultRunProperties != null)  //Only paragraph!
                {
                    float points = float.Parse(par.defaultRunProperties.FontSize.ToString()) * 72.0F / 96.0F;
                    System.Drawing.Font font = new System.Drawing.Font(par.defaultRunProperties.FontFamily.ToString(), points);
                    newTop = font.Height;
                }
                List<HtexText> processedElements = new List<HtexText>();
                IEnumerable<PPTRunProperties> pPTRunProperties = breakTextsToShape(par);
                foreach (var text in pPTRunProperties)
                {
                    float points = float.Parse(text.FontSize.ToString()) * 72.0F / 96.0F;
                    System.Drawing.Font font = new System.Drawing.Font(text.FontFamily.ToString(), points);
                    if (text.Bold) font = new System.Drawing.Font(text.FontFamily.ToString(), points, System.Drawing.FontStyle.Bold);
                    else if (text.Italic)
                        font = new System.Drawing.Font(text.FontFamily.ToString(), points, System.Drawing.FontStyle.Italic);
                    else if (text.Underline != null && text.Underline.Equals("Single"))
                        font = new System.Drawing.Font(text.FontFamily.ToString(), points, System.Drawing.FontStyle.Underline);
                    newTop = font.Height > newTop ? font.Height : newTop;
                    newTop = par.getLineSpacingInPointsFromFont(newTop);
                    if (text.isBreak)
                    {
                        top += newTop;
                        left = 0;
                        fixLeftSpacingForAlignment(processedElements, par, font);
                        processedElements.Clear();
                        continue;
                    }
                    String currentString = text.Text.TrimEnd() + getStringFromTextElements(processedElements);
                    HtexText t1 = new HtexText(left: left,
                                            top: top,
                                            fontFamily: text.FontFamily,
                                            fontColor: text.FontColor,
                                            fontSize: text.FontSize,
                                            isBullet: text.isBullet,
                                            bold: text.Bold,
                                            italic: text.Italic,
                                            underline: text.Underline,
                                            id: id,
                                            slideIndex: slide.slideIndex)
                    {
                        Rotate = this.rot
                    };
                    t1.width = MeasureString(text.Text, font);

                    if (text.isBullet && text.Text != null && text.Text.Contains("rId"))
                    {
                        t1.PictureBullet = true;
                        t1.width = text.bulletSize;
                        t1.bulletSize = text.bulletSize;
                        newTop = text.bulletSize;
                    }
                    t1.Text = text.Text;
                    textElements.Add(t1);
                    texts.Add(new Text
                    {
                        content = t1.Text,
                        link=text.link,
                        linkType=text.linkType,
                        style = new FontStyle
                        {
                            align = par.FontAlign,
                            spacing = par.defTabSize,
                            color = text.FontColor,
                            family = text.FontFamily,
                            top = top,
                            left = left,
                            size = text.FontSize,
                            isBullet = text.isBullet,
                            underline = t1.underline,
                            italic = text.Italic,
                            bold = text.Bold,
                            rot = this.rot,
                            width = t1.width,
                            pictureBullet = t1.PictureBullet,
                            bulletSize = t1.bulletSize
                        }
                    }); 
                    processedElements.Add(t1);
                }
                fixLeftSpacingForAlignment(processedElements, par);

                HtexText lastTxt = null;
                List<HtexText> mergedTextElements = new List<HtexText>();
                foreach (HtexText textElement in textElements)
                {
                    if (lastTxt == null || !lastTxt.sameProps(textElement))
                        mergedTextElements.Add(textElement);
                    else
                        mergedTextElements[mergedTextElements.Count - 1].Text += textElement.Text;

                    lastTxt = textElement;
                }

                //foreach (HtexText textElement in mergedTextElements) {
                // shapeBuilder.Append(textElement.DrawElement());
                //}

                top += newTop;
                top += par.getSpaceAfterPoints(newTop);
                top += par.getSpaceBeforePoints(newTop);


                paragraph.texts = texts;
                Paragraphs.Add(paragraph);
            }
            return Paragraphs;
        }
        private String getStringFromTextElements(List<HtexText> elements)
        {
            if (elements == null || elements.Count == 0)
                return "";
            StringBuilder result = new StringBuilder();
            foreach (HtexText el in elements)
            {
                result.Append(el.Text);
            }
            return result.ToString();
        }//We have two similar methods - this one is better because it measures the whole string with the font. 
        private void fixLeftSpacingForAlignment(List<HtexText> textElements, PPTParagraph par, System.Drawing.Font font)
        {
            int combinedWidth = 0;

            StringBuilder combinedText = new StringBuilder();
            foreach (HtexText textElement in textElements)
            {
                if (textElement.PictureBullet)
                    combinedWidth += textElement.bulletSize;
                else
                    combinedText.Append(textElement.Text);
            }
            int bulletOffset = 0;
            if (par.bullet != null && textElements.Count > 0 && !textElements[0].isBullet)
            {
                bulletOffset = par.bullet.bulletSize;
                combinedWidth += par.bullet.bulletSize;
            }
            combinedWidth += MeasureString(combinedText.ToString(), font);

            double firstLeft = 0;
            if ("Center".Equals(par.Align))
                firstLeft = ((this.width - par.Indent - bulletOffset - par.marginLeft - par.marginRight) - combinedWidth) / 2;
            else if ("Right".Equals(par.Align))
                firstLeft = (this.width - par.Indent - bulletOffset - par.marginLeft - par.marginRight) - combinedWidth;
            combinedText = new StringBuilder();
            combinedWidth = 0; //Now used only for picture bullets!
            foreach (HtexText textElement in textElements)
            {
                textElement.setLeft(firstLeft + par.Indent + bulletOffset + par.marginLeft + combinedWidth + MeasureString(combinedText.ToString(), font));
                if (textElement.PictureBullet)
                    combinedWidth += textElement.bulletSize;
                else
                    combinedText.Append(textElement.Text);
            }
        }//We have two similar methods. This is worse because it uses the Width property of each element instead of measuring the whole string. 
        //There is mistake in the calculations coming from that and the difference is bigger when there are more elements. 
        private void fixLeftSpacingForAlignment(List<HtexText> textElements, PPTParagraph par)
        {
            int combinedWidth = 0;

            foreach (HtexText textElement in textElements)
                combinedWidth += textElement.width;
            int bulletOffset = 0;
            if (par.bullet != null && textElements.Count > 0 && !textElements[0].isBullet)
            {
                combinedWidth += par.bullet.bulletSize;
                bulletOffset = par.bullet.bulletSize;
            }

            double currentLeft = 0;
            if ("Center".Equals(par.Align))
                currentLeft = ((this.width - par.Indent - bulletOffset - par.marginLeft - par.marginRight) - combinedWidth) / 2;
            else if ("Right".Equals(par.Align))
                currentLeft = (this.width - par.Indent - bulletOffset - par.marginLeft - par.marginRight) - combinedWidth;

            foreach (HtexText textElement in textElements)
            {
                textElement.setLeft(currentLeft + par.Indent + bulletOffset + par.marginLeft);
                currentLeft += textElement.width;
            }
        }
        private IEnumerable<PPTRunProperties> breakTextsToShape(PPTParagraph par)
        {
            List<PPTRunProperties> list = par.RunPropList;
            List<PPTRunProperties> result = new List<PPTRunProperties>();
            String previousToken = null;
            int bulletSize = 0;
            foreach (var text in list)
            {
                float points = float.Parse(text.FontSize.ToString()) * 72.0F / 96.0F;
                System.Drawing.Font font = new System.Drawing.Font(text.FontFamily.ToString(), points);
                if (text.Bold) font = new System.Drawing.Font(text.FontFamily.ToString(), points, System.Drawing.FontStyle.Bold);
                else if (text.Italic) font = new System.Drawing.Font(text.FontFamily.ToString(), points, System.Drawing.FontStyle.Italic);
                else if (text.Underline != null && text.Underline.Equals("Single"))
                    font = new System.Drawing.Font(text.FontFamily.ToString(), points, System.Drawing.FontStyle.Underline);

                int size = 0;
                if (text.isBullet && text.Text != null && text.Text.Contains("rId"))
                    bulletSize = text.bulletSize;
                else
                    size = MeasureString((previousToken == null ? "" : previousToken + " ") + text.Text, font);
                if (text.isBreak || size + bulletSize < this.width - par.Indent - par.marginLeft - par.marginRight)//- Shape.LeftInset - Shape.RightInset)
                {
                    if (text.Text != null && text.Text.Trim() != "" && !(text.isBullet && text.Text.Contains("rId")))
                    {
                        previousToken = (previousToken == null ? "" : previousToken) + text.Text;
                    }
                    if (text.isBreak)
                        previousToken = null;
                    result.Add(text);
                    continue;
                }

                //   previousToken = null;

                string[] tokens = text.Text.Split(' ');
                int index = 0;
                foreach (string token in tokens)
                {
                    index++;
                    int combinedSize = MeasureString((previousToken == null ? "" : previousToken + " ") + token, font);

                    if (combinedSize + bulletSize > this.width - par.Indent - par.marginLeft - par.marginRight)//- Shape.LeftInset - Shape.RightInset)
                    {
                        PPTRunProperties temp = new PPTRunProperties(text);
                        temp.Text = "";
                        temp.isBreak = true;
                        result.Add(temp);

                        temp = new PPTRunProperties(text);
                        temp.Text = index < tokens.Length ? token + " " : token;
                        result.Add(temp);
                        previousToken = token;
                    }
                    else
                    {
                        PPTRunProperties temp = new PPTRunProperties(text);
                        temp.Text = index < tokens.Length ? token + " " : token;
                        result.Add(temp);
                        previousToken = (previousToken == null ? "" : previousToken + " ") + token;
                    }
                }
            }
            return result;
        }
        public static int MeasureString(string s, System.Drawing.Font font)
        {
            s = s.Replace("\t", "aaaa");//TODO the replace is dirty hack for measuring tabulations

            StringFormat stringFormat = new StringFormat(StringFormat.GenericTypographic);
            CharacterRange[] rng = { new CharacterRange(0, s.Length) };
            stringFormat.SetMeasurableCharacterRanges(rng);
            Graphics g = Graphics.FromImage(new Bitmap(100, 100));
            //Use measure character ranges with a big box because we used this for measurement only
            //Later we might better use this for drawing the text. 
            Region[] regions = g.MeasureCharacterRanges(s, font, new System.Drawing.Rectangle(0, 0, 10000, 3000), stringFormat);
            foreach (Region region in regions)
            {
                RectangleF rect = region.GetBounds(g);
                return (int)System.Math.Round(rect.Width);
            }
            return 0;

            // 
            //             SizeF result;
            //             using (var image = new Bitmap(1, 1))
            //             {
            //                 using (var g = Graphics.FromImage(image))
            //                 {
            //                     result = g.MeasureString(s, font);
            //                 }
            //             }
            // 
            //             return result.ToSize();
        }
       
        private bool GetParagraphChildElements(RichText shape, PPTParagraph par, bool hasText, OpenXmlElement obj, int fontScale)
        {
            LinkedList<string> effectShapes = new LinkedList<string>();
            if (obj is Run)
            {
                Run run = (Run)obj;
                hasText = true;
                PPTRunProperties runProp = new PPTRunProperties(par.defaultRunProperties);
                runProp.Text = run.Text.Text;
                runProp.SetRunProperties(run.RunProperties, shape, ref effectShapes);
                runProp.FontSize = System.Math.Round(fontScale * runProp.FontSize / Globals.PercentageConstant);
                par.RunPropList.Add(runProp);
            }

            else if (obj is Field)
            {
                Field run = (Field)obj;
                hasText = true;
                PPTRunProperties runProp = new PPTRunProperties(par.defaultRunProperties);
                runProp.Text = run.Text.Text;
                runProp.SetRunProperties(run.RunProperties, shape, ref effectShapes);
                runProp.FontSize = System.Math.Round(fontScale * runProp.FontSize / Globals.PercentageConstant);
                par.RunPropList.Add(runProp);
            }

            else if (obj is Break)
            {
                Break aBreak = (Break)obj;
                PPTRunProperties runProp = new PPTRunProperties(par.defaultRunProperties);
                runProp.SetRunProperties(aBreak.RunProperties, shape, ref effectShapes);
                runProp.FontSize = System.Math.Round(fontScale * runProp.FontSize / Globals.PercentageConstant);
                runProp.isBreak = true;
                par.RunPropList.Add(runProp);
            }
            return hasText;
        }
        public List<CommonChart> DoPlotArea(PlotArea plotArea) {
            List<CommonChart> charts = new List<CommonChart>();
            foreach (var child in plotArea.ChildElements)
            {
                string key = child.LocalName;
                IEnumerable<XElement> serNodes = null;
                switch (key)
                {
                    //break块中不可以随意更换，此条件用于归类不同从Chart
                    case "pieChart":
                    case "ofPieChart":
                    case "pie3DChart":
                    case "doughnutChart":
                        PieChart pieChart = new PieChart { chartType = "pie" };
                        if (key.Equals("pie3DChart"))
                        {
                            pieChart.is3D = true;
                        }
                        pieChart.pieType = key;
                        if (key.Equals("ofPieChart"))
                        {
                            var ofPieType = child.GetTextByPath("c:ofPieType");
                            if (ofPieType != null)
                            {
                                //ofPieChart-pie ofPieChart-bar  子母饼图
                                pieChart.pieType += "-" + ofPieType.Attribute("val").Value;
                            }
                        }
                        serNodes = child.GetTextByPathList("c:ser");
                        pieChart.datas = ExtractChartData(serNodes);
                        charts.Add(pieChart);
                        break;
                    case "lineChart":
                    case "line3DChart":
                        LineChart lineChart = new LineChart { chartType = "line" };
                        if (key.Equals("line3DChart"))
                        {
                            lineChart.is3D = true;
                        }
                        lineChart.lineType = key;
                        var LineGrouping = child.GetTextByPath("c:grouping");
                        if (LineGrouping != null)
                        {
                            //standard stacked percentStacked
                            lineChart.lineType += "-" + LineGrouping.Attribute("val").Value;
                        }
                        serNodes = child.GetTextByPathList("c:ser");
                        lineChart.datas = ExtractChartData(serNodes);
                        charts.Add(lineChart);
                        break;
                    case "barChart":
                    case "bar3DChart":
                        var barDir = child.GetTextByPath("c:barDir");
                        if (barDir != null)
                        {
                            if (barDir.Attribute("val").Value.Equals("bar"))
                            {
                                BarChart barChart = new BarChart { chartType = "bar" };
                                charts.Add(barChart);
                                if (key.Equals("bar3DChart"))
                                {
                                    barChart.is3D = true;
                                }

                                barChart.barType = key;
                                var BarGrouping = child.GetTextByPath("c:grouping");
                                if (BarGrouping != null)
                                {
                                    //standard stacked percentStacked
                                    barChart.barType += "-" + BarGrouping.Attribute("val").Value;
                                }
                                serNodes = child.GetTextByPathList("c:ser");
                                barChart.datas = ExtractChartData(serNodes);
                                charts.Add(barChart);
                            }
                            else if (barDir.Attribute("val").Value.Equals("col"))
                            {
                                ColChart colChart = new ColChart { chartType = "col" };
                                if (key.Equals("bar3DChart"))
                                {
                                    colChart.is3D = true;
                                }
                                colChart.colType = key.Replace("bar", "col");
                                var ColGrouping = child.GetTextByPath("c:grouping");
                                if (ColGrouping != null)
                                {
                                    //standard stacked percentStacked
                                    colChart.colType += "-" + ColGrouping.Attribute("val").Value;
                                }
                                serNodes = child.GetTextByPathList("c:ser");
                                colChart.datas = ExtractChartData(serNodes);
                                charts.Add(colChart);
                            }
                        }
                        break;
                    case "areaChart":
                    case "area3DChart":
                        AreaChart areaChart = new AreaChart { chartType = "area" };
                        if (key.Equals("area3DChart"))
                        {
                            areaChart.is3D = true;
                        }
                        areaChart.areaType = key;
                        var AreaGrouping = child.GetTextByPath("c:grouping");
                        if (AreaGrouping != null)
                        {
                            //standard stacked percentStacked
                            areaChart.areaType += "-" + AreaGrouping.Attribute("val").Value;
                        }
                        serNodes = child.GetTextByPathList("c:ser");
                        areaChart.datas = ExtractChartData(serNodes);
                        charts.Add(areaChart);
                        break;
                    case "scatterChart":
                    case "bubbleChart":
                        ScatterChart scatterChart = new ScatterChart { chartType = "scatter" };
                        scatterChart.scatterType = key;
                        if (key.Equals("scatterChart"))
                        {
                            var ScatterStyle = child.GetTextByPath("c:scatterStyle");
                            if (ScatterStyle != null)
                            {
                                scatterChart.scatterType += "-" + ScatterStyle.Attribute("val").Value.Replace("Marker", "");
                            }
                        }
                        serNodes = child.GetTextByPathList("c:ser");
                        scatterChart.datas = ExtractChartData(serNodes);
                        charts.Add(scatterChart);
                        break;
                    case "radarChart":
                        RadarChart radarChart = new RadarChart { chartType = "radar" };
                        radarChart.radarType = key;
                        var RadarStyle = child.GetTextByPath("c:radarStyle");
                        if (RadarStyle != null)
                        {
                            radarChart.radarType += "-" + RadarStyle.Attribute("val").Value;
                        }
                        serNodes = child.GetTextByPathList("c:ser");
                        radarChart.datas = ExtractChartData(serNodes);
                        charts.Add(radarChart);
                        break;
                    case "plotAreaRegion":
                        PlotAreaChart plotAreaChart = new PlotAreaChart { chartType = "plotArea" };
                        plotAreaChart.plotAreaType = key;
                        var PlotSeries = child.GetTextByPath("cx:series");
                        if (PlotSeries != null)
                        {
                            plotAreaChart.plotAreaType += "-" + PlotSeries.Attribute("val").Value;
                        }
                        serNodes = child.GetTextByPathList("c:ser");
                        plotAreaChart.datas = ExtractChartData(serNodes);
                        charts.Add(plotAreaChart);
                        break;
                    case "stockChart":
                        StockChart stockChart = new StockChart { chartType = "stock" };
                        stockChart.stockType = key;
                        serNodes = child.GetTextByPathList("c:ser");
                        stockChart.datas = ExtractChartData(serNodes);
                        charts.Add(stockChart);
                        break;
                    case "surfaceChart":
                    case "surface3DChart":
                        SurfaceChart surfaceChart = new SurfaceChart { chartType = "surface" };
                        if (key.Equals("surface3DChart"))
                        {
                            surfaceChart.is3D = true;
                        }
                        surfaceChart.surfaceType = key;
                        var Wireframe = child.GetTextByPath("c:wireframe");
                        if (Wireframe != null)
                        {
                            surfaceChart.surfaceType += "-" + Wireframe.Attribute("val").Value;
                        }
                        serNodes = child.GetTextByPathList("c:ser");
                        surfaceChart.datas = ExtractChartData(serNodes);
                        charts.Add(surfaceChart);
                        break;
                }
            }
            return charts;
        }

        public   List<Dictionary<string, object>> ExtractChartData(IEnumerable<XElement> nodes)
        {

            if (nodes != null)
            {
                List<Dictionary<string, object>> listDict = new List<Dictionary<string, object>>();
                foreach (XElement node in nodes)
                {

                    if (node.GetTextByPath("c:xVal") != null)
                    {
                        Dictionary<string, object> dict = new Dictionary<string, object>();
                        var xCvNodes = node.GetTextByPathList("c:xVal/c:numRef/c:numCache/c:pt/c:v");
                        if (xCvNodes != null)
                        {
                            List<string> list = new List<string>();
                            foreach (XElement cvNode in xCvNodes)
                            {
                                list.Add(cvNode.Value);
                            }
                            dict.Add("xAxis", list);
                        }
                        var yCvNodes = node.GetTextByPathList("c:yVal/c:numRef/c:numCache/c:pt/c:v");
                        if (yCvNodes != null)
                        {
                            List<string> list = new List<string>();
                            foreach (XElement cvNode in yCvNodes)
                            {
                                list.Add(cvNode.Value);
                            }
                            dict.Add("yAxis", list);
                        }
                        dict.Add("colName", "-");
                        listDict.Add(dict);
                    }
                    else
                    {
                        Dictionary<string, object> dict = new Dictionary<string, object>();
                        var spPr = node.GetTextByPath("c:spPr");
                        if (spPr != null)
                        {
                            var ChartShapeProperties = new ChartShapeProperties(spPr.ToString());
                            ShapeStyle shapeStyle = PPTXHelper.DoShapeProperties(ChartShapeProperties, slide, type, partForm,chartPart);
                            dict.Add("colStyle", shapeStyle);
                        }
                        else {
                            dict.Add("colStyle", null);
                        }
                        var colNameNode = node.GetTextByPath("c:tx/c:strRef/c:strCache/c:pt/c:v");
                        if (colNameNode != null)
                        {
                            dict.Add("colName", colNameNode.Value);
                           
                        }
                        //name
                        var catNodes = node.GetTextByPathList("c:cat/c:strRef/c:strCache/c:pt/c:v");
                        if (catNodes == null)
                        {
                            catNodes = node.GetTextByPathList("c:cat/c:numRef/c:numCache/c:pt/c:v");
                        }
                        if (catNodes != null)
                        {
                            List<string> list = new List<string>();
                            foreach (XElement cvNode in catNodes)
                            {
                                list.Add(cvNode.Value);
                            }
                            dict.Add("xAxis", list);
                        }
                        //value
                        var valNodes = node.GetTextByPathList("c:val/c:numRef/c:numCache/c:pt/c:v");
                        if (valNodes != null)
                        {
                            List<string> list = new List<string>();
                            foreach (XElement cvNode in valNodes)
                            {
                                list.Add(cvNode.Value);
                            }
                            dict.Add("yAxis", list);
                        }
                        listDict.Add(dict);
                    }
                }
                return listDict;
            }
            return null;
        }

        public void DoStyleEntry(DocumentFormat.OpenXml.Office2013.Drawing.ChartStyle.StyleEntry StyleEntry)
        {
            //TODO
            /*
          * LineReference
            LineWidthScale
            FillReference
            EffectReference
            FontReference
            ShapeProperties
            TextCharacterPropertiesType
            TextBodyProperties
            OfficeArtExtensionList
          * */
            var LineReference =  StyleEntry.LineReference;
            var LineWidthScale=  StyleEntry.LineWidthScale;
            var FillReference=   StyleEntry.FillReference;
            var EffectReference = StyleEntry.EffectReference;
            var FontReference= StyleEntry.FontReference;
            var ShapeProperties = StyleEntry.ShapeProperties;
            var TextCharacterPropertiesType = StyleEntry.TextCharacterPropertiesType;
            var TextBodyProperties = StyleEntry.TextBodyProperties;
            var OfficeArtExtensionList = StyleEntry.OfficeArtExtensionList;
        }
    }

   
    public class ChartStyle { 
    //

    }
}