using System;
using System.Collections.Generic;
using System.IO;
using System.IO.Compression;
using System.Linq;

namespace WpfOfdReader.OfdFileType
{
  class OfdFileReader
  {
    ZipArchive _zipArchive;
    public void ReadZipFile(string fileName)
    {
      _zipArchive = ZipFile.OpenRead(fileName);
    }

    public void Close()
    {
      if (_zipArchive != null)
        _zipArchive.Dispose();
    }

    public List<OfdFileItemInfo> AllFileItem
    {
      get
      {
        return _zipArchive.Entries.Select(o => new OfdFileItemInfo(o)).ToList();
      }
    }

    private ZipArchiveEntry GetArchiveEntry(ZipFilePath path)
    {
      foreach (ZipArchiveEntry entry in _zipArchive.Entries)
      {
        if (entry.FullName == path.FulleName)
        {
          return entry;
        }
      }
      return null;
    }

    public static byte[] GetFileBuffer(ZipArchiveEntry entry)
    {
      List<byte[]> listBuffer = new List<byte[]>();
      using (Stream s = entry.Open())
      {
        while (true)
        {
          byte[] buffer = new byte[10];
          int n = s.Read(buffer, 0, buffer.Length);
          if (n <= 0)
            break;

          if (n == buffer.Length)
          {
            listBuffer.Add(buffer);
          }
          else
          {
            Array.Resize(ref buffer, n);
            listBuffer.Add(buffer);
            break;
          }
        }
      }

      int totalLen = 0;
      listBuffer.ForEach(o => totalLen += o.Length);
      byte[] result = new byte[totalLen];
      int index = 0;
      foreach (byte[] buffer in listBuffer)
      {
        Buffer.BlockCopy(buffer, 0, result, index, buffer.Length);
        index += buffer.Length;
      }
      return result;
    }
  }
}

  public class PageObject
  {
    public string ID { get; set; }
    public PageLayer ParentLayer { get; set; }
    public string PageFileLoc => ParentLayer.ParentPage.PageFileLoc;

    XmlNode _xmlNode;

    public string Boundary { get; set; }
    public string CTM { get; set; }

    public OfdClipsGroup ClipsGroup { get; set; }

    public void SetPageObject(PageLayer layer, XmlNode xmlNode)
    {
      _xmlNode = xmlNode;

      ID = XmlHelper.GetXmlAttributeValue(xmlNode, "ID");
      ParentLayer = layer;

      Boundary = XmlHelper.GetXmlAttributeValue(xmlNode, "Boundary");
      CTM = XmlHelper.GetXmlAttributeValue(xmlNode, "CTM");

      foreach (XmlNode childNode in xmlNode.ChildNodes)
      {
        if (childNode.Name == OfdClipsGroup.XML_Name)
        {
          ClipsGroup = OfdClipsGroup.FromXml(childNode);
          break;
        }
      }

    }

    public string GetAttributeValue(string name)
    {
      string result = XmlHelper.GetXmlAttributeValue(_xmlNode, name);
      return result;
    }

  }

  public class OfdVisual : DrawingVisual
  {
    public OfdVisual()
    {
    }

    protected DrawingCanvas _drawingCanvas;
    public DrawingCanvas DrawingCanvas
    {
      get
      {
        return _drawingCanvas;
      }
    }

    public bool IsAddToCanvas
    {
      get
      {
        return _drawingCanvas != null;
      }
    }


    internal void AddToCanvas(DrawingCanvas drawingCanvas)
    {
      if (_drawingCanvas == drawingCanvas)
        return;
      _drawingCanvas = drawingCanvas;
      _drawingCanvas.AddVisual(this);
    }

    public void ReomveFromCanvas()
    {
      if (_drawingCanvas != null)
      {
        _drawingCanvas.DeleteVisual(this);
      }
    }

    public virtual void Show(bool visiable, bool even = false)
    {

    }

    public Point BoundaryLocation { get; set; }
    public Size BoundarySize { get; set; }

    public MatrixTransform ObjectTransform { get; protected set; }

    public VisualClipsGroup ObjectClipsGroup { get; protected set; }
    public void SetPageObject(PageObject pageObject)
    {
      OfdHelper.ParseBoundary(pageObject.Boundary, out Point location, out Size size);
      BoundaryLocation = location;
      BoundarySize = size;

      if (!string.IsNullOrEmpty(pageObject.CTM))
      {
        ObjectTransform = OfdHelper.OfdTextToTransform(pageObject.CTM);
      }

      if (pageObject.ClipsGroup != null)
      {
        ObjectClipsGroup = new VisualClipsGroup() { ClipsGroup = pageObject.ClipsGroup };
      }
    }

    protected Rect ClipRect
    {
      get
      {
        return new Rect(0, 0, BoundarySize.Width, BoundarySize.Height);
      }
    }

    protected RectangleGeometry ClipGeometry
    {
      get
      {
        RectangleGeometry geometry = new RectangleGeometry(ClipRect);
        return geometry;
      }
    }


    protected void PutBoundary(DrawingContext dc)
    {
      TranslateTransform translateBoundary = new TranslateTransform(BoundaryLocation.X, BoundaryLocation.Y);
      dc.PushTransform(translateBoundary);
      dc.PushClip(ClipGeometry);
    }

    protected void PopBoundary(DrawingContext dc)
    {
      dc.Pop();
      dc.Pop();
    }

    protected void PutTransform(DrawingContext dc)
    {
      if (ObjectTransform != null)
      {
        dc.PushTransform(ObjectTransform);
      }
    }

    protected void PopTransform(DrawingContext dc)
    {
      if (ObjectTransform != null)
      {
        dc.Pop();
      }
    }
  }

public override void Show(bool visiable, bool even = false)；

 void DrawText()
    {
      using (DrawingContext dc = RenderOpen())
      {
        if (ObjectClipsGroup == null)
        {
          PutBoundary(dc);
          PutTransform(dc);

          DrawTextInner(dc);

          PopTransform(dc);
          PopBoundary(dc);
        }
        else
        {
          foreach (VisulClip visulClip in ObjectClipsGroup)
          {
            PutBoundary(dc);
            visulClip.PutClip(dc);
            PutTransform(dc);

            DrawTextInner(dc);

            PopTransform(dc);
            visulClip.PopClip(dc);
            PopBoundary(dc);
          }
        }
      }
    }

    private void DrawTextInner(DrawingContext dc)
    {
      int i = -1;
      double deltaXTotal = 0;
      double deltaYTotal = 0;
      Point pt = new Point();

      foreach (FormattedText formattedText in FormattedTextCollection)
      {
        i++;
        if (i != 0)
        {
          if (DeltaCollectionX != null)
          {
            double deltaX = DeltaCollectionX.GetValue(i - 1);
            deltaXTotal += deltaX;
          }

          if (DeltaCollectionY != null)
          {
            double deltaY = DeltaCollectionY.GetValue(i - 1);
            deltaYTotal += deltaY;
          }
        }

        pt.X = TextLocation.X + deltaXTotal;
        pt.Y = TextLocation.Y + deltaYTotal - FormattedTextCollection.FontBaseLine;
        dc.DrawText(formattedText, pt);
      }
    }