using System;
using System.Text;
using System.Collections.Generic;

using iTextSharp.text;

/*
 * $Id: PdfLine.cs 209 2010-11-13 15:33:56Z psoares33 $
 * 
 *
 * This file is part of the iText project.
 * Copyright (c) 1998-2012 1T3XT BVBA
 * Authors: Bruno Lowagie, Paulo Soares, et al.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License version 3
 * as published by the Free Software Foundation with the addition of the
 * following permission added to Section 15 as permitted in Section 7(a):
 * FOR ANY PART OF THE COVERED WORK IN WHICH THE COPYRIGHT IS OWNED BY 1T3XT,
 * 1T3XT DISCLAIMS THE WARRANTY OF NON INFRINGEMENT OF THIRD PARTY RIGHTS.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 * or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNU Affero General Public License for more details.
 * You should have received a copy of the GNU Affero General Public License
 * along with this program; if not, see http://www.gnu.org/licenses or write to
 * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA, 02110-1301 USA, or download the license from the following URL:
 * http://itextpdf.com/terms-of-use/
 *
 * The interactive user interfaces in modified source and object code versions
 * of this program must display Appropriate Legal Notices, as required under
 * Section 5 of the GNU Affero General Public License.
 *
 * In accordance with Section 7(b) of the GNU Affero General Public License,
 * you must retain the producer line in every PDF that is created or manipulated
 * using iText.
 *
 * You can be released from the requirements of the license by purchasing
 * a commercial license. Buying such a license is mandatory as soon as you
 * develop commercial activities involving the iText software without
 * disclosing the source code of your own applications.
 * These activities include: offering paid services to customers as an ASP,
 * serving PDFs on the fly in a web application, shipping iText with a closed
 * source product.
 *
 * For more information, please contact iText Software Corp. at this
 * address: sales@itextpdf.com
 */

namespace iTextSharp.text.pdf {

    /**
     * <CODE>PdfLine</CODE> defines an array with <CODE>PdfChunk</CODE>-objects
     * that fit into 1 line.
     */

    public class PdfLine {
    
        // membervariables
    
        /** The arraylist containing the chunks. */
        protected internal List<PdfChunk> line;
    
        /** The left indentation of the line. */
        protected internal float left;
    
        /** The width of the line. */
        protected internal float width;
    
        /** The alignment of the line. */
        protected internal int alignment;
    
        /** The heigth of the line. */
        protected internal float height;
    
        /** The listsymbol (if necessary). */
        protected internal Chunk listSymbol = null;
    
        /** The listsymbol (if necessary). */
        protected internal float symbolIndent;
    
        /** <CODE>true</CODE> if the chunk splitting was caused by a newline. */
        protected internal bool newlineSplit = false;
    
        /** The original width. */
        protected internal float originalWidth;
    
        protected internal bool isRTL = false;
    
        // constructors
    
        /**
         * Constructs a new <CODE>PdfLine</CODE>-object.
         *
         * @param    left        the limit of the line at the left
         * @param    right        the limit of the line at the right
         * @param    alignment    the alignment of the line
         * @param    height        the height of the line
         */
    
        internal PdfLine(float left, float right, int alignment, float height) {
            this.left = left;
            this.width = right - left;
            this.originalWidth = this.width;
            this.alignment = alignment;
            this.height = height;
            this.line = new List<PdfChunk>();
        }
    
        /**
        * Creates a PdfLine object.
        * @param left              the left offset
        * @param originalWidth     the original width of the line
        * @param remainingWidth    bigger than 0 if the line isn't completely filled
        * @param alignment         the alignment of the line
        * @param newlineSplit      was the line splitted (or does the paragraph end with this line)
        * @param line              an array of PdfChunk objects
        * @param isRTL             do you have to read the line from Right to Left?
        */
        internal PdfLine(float left, float originalWidth, float remainingWidth, int alignment, bool newlineSplit, List<PdfChunk> line, bool isRTL) {
            this.left = left;
            this.originalWidth = originalWidth;
            this.width = remainingWidth;
            this.alignment = alignment;
            this.line = line;
            this.newlineSplit = newlineSplit;
            this.isRTL = isRTL;
        }
    
        // methods
    
        /**
         * Adds a <CODE>PdfChunk</CODE> to the <CODE>PdfLine</CODE>.
         *
         * @param        chunk        the <CODE>PdfChunk</CODE> to add
         * @return        <CODE>null</CODE> if the chunk could be added completely; if not
         *                a <CODE>PdfChunk</CODE> containing the part of the chunk that could
         *                not be added is returned
         */
    
        internal PdfChunk Add(PdfChunk chunk) {
            // nothing happens if the chunk is null.
            if (chunk == null || chunk.ToString().Equals("")) {
                return null;
            }
        
            // we split the chunk to be added
            PdfChunk overflow = chunk.Split(width);
            newlineSplit = (chunk.IsNewlineSplit() || overflow == null);
            //        if (chunk.IsNewlineSplit() && alignment == Element.ALIGN_JUSTIFIED)
            //            alignment = Element.ALIGN_LEFT;
            if (chunk.IsTab()) {
                Object[] tab = (Object[])chunk.GetAttribute(Chunk.TAB);
                float tabPosition = (float)tab[1];
                bool newline = (bool)tab[2];
                if (newline && tabPosition < originalWidth - width) {
                    return chunk;
                }
                width = originalWidth - tabPosition;
                chunk.AdjustLeft(left);
                AddToLine(chunk);
            }
            // if the length of the chunk > 0 we add it to the line
            else if (chunk.Length > 0 || chunk.IsImage()) {
                if (overflow != null)
                    chunk.TrimLastSpace();
                width -= chunk.Width;
                AddToLine(chunk);
            }
        
                // if the length == 0 and there were no other chunks added to the line yet,
                // we risk to end up in an endless loop trying endlessly to add the same chunk
            else if (line.Count < 1) {
                chunk = overflow;
                overflow = chunk.Truncate(width);
                width -= chunk.Width;
                if (chunk.Length > 0) {
                    AddToLine(chunk);
                    return overflow;
                }
                    // if the chunck couldn't even be truncated, we add everything, so be it
                else {
                    if (overflow != null)
                        AddToLine(chunk);
                    return null;
                }
            }
            else {
                width += ((PdfChunk)(line[line.Count - 1])).TrimLastSpace();
            }
            return overflow;
        }
    
        private void AddToLine(PdfChunk chunk) {
            if (chunk.ChangeLeading && chunk.IsImage()) {
                Image img = chunk.Image;
                float f = img.ScaledHeight + chunk.ImageOffsetY
                    + img.BorderWidthTop + img.SpacingBefore;
                if (f > height) height = f;
            }
            line.Add(chunk);
        }

        // methods to retrieve information
    
        /**
         * Returns the number of chunks in the line.
         *
         * @return    a value
         */
    
        public int Size {
            get {
                return line.Count;
            }
        }
    
        /**
         * Returns an iterator of <CODE>PdfChunk</CODE>s.
         *
         * @return    an <CODE>Iterator</CODE>
         */
    
        public IEnumerator<PdfChunk> GetEnumerator() {
            return line.GetEnumerator();
        }
    
        /**
         * Returns the height of the line.
         *
         * @return    a value
         */
    
        internal float Height {
            get {
                return height;
            }
        }
    
        /**
         * Returns the left indentation of the line taking the alignment of the line into account.
         *
         * @return    a value
         */
    
        internal  float IndentLeft {
            get {
                if (isRTL) {
                    switch (alignment) {
                        case Element.ALIGN_LEFT:
                            return left + width;
                        case Element.ALIGN_CENTER:
                            return left + (width / 2f);
                        default:
                            return left;
                    }
                }
                else if (this.GetSeparatorCount() <= 0) {
                    switch (alignment) {
                        case Element.ALIGN_RIGHT:
                            return left + width;
                        case Element.ALIGN_CENTER:
                            return left + (width / 2f);
                    }
                }
                return left;
            }
        }
    
        /**
         * Checks if this line has to be justified.
         *
         * @return    <CODE>true</CODE> if the alignment equals <VAR>ALIGN_JUSTIFIED</VAR> and there is some width left.
         */
    
        public bool HasToBeJustified() {
            return ((alignment == Element.ALIGN_JUSTIFIED || alignment == Element.ALIGN_JUSTIFIED_ALL) && width != 0);
        }
    
        /**
         * Resets the alignment of this line.
         * <P>
         * The alignment of the last line of for instance a <CODE>Paragraph</CODE>
         * that has to be justified, has to be reset to <VAR>ALIGN_LEFT</VAR>.
         */
    
        public void ResetAlignment() {
            if (alignment == Element.ALIGN_JUSTIFIED) {
                alignment = Element.ALIGN_LEFT;
            }
        }
    
        /** Adds extra indentation to the left (for Paragraph.setFirstLineIndent). */
        internal void SetExtraIndent(float extra) {
            left += extra;
            width -= extra;
            originalWidth -= extra;
        }

        /**
         * Returns the width that is left, after a maximum of characters is added to the line.
         *
         * @return    a value
         */
    
        internal float WidthLeft {
            get {
                return width;
            }
        }
    
        /**
         * Returns the number of space-characters in this line.
         *
         * @return    a value
         */
    
        internal int NumberOfSpaces {
            get {
                string str = ToString();
                int length = str.Length;
                int numberOfSpaces = 0;
                for (int i = 0; i < length; i++) {
                    if (str[i] == ' ') {
                        numberOfSpaces++;
                    }
                }
                return numberOfSpaces;
            }
        }
    
        /**
         * Sets the listsymbol of this line.
         * <P>
         * This is only necessary for the first line of a <CODE>ListItem</CODE>.
         *
         * @param listItem the list symbol
         */
    
        public ListItem ListItem {
            set {
                this.listSymbol = value.ListSymbol;
                this.symbolIndent = value.IndentationLeft;
            }
        }
    
        /**
         * Returns the listsymbol of this line.
         *
         * @return    a <CODE>PdfChunk</CODE> if the line has a listsymbol; <CODE>null</CODE> otherwise
         */
    
        public Chunk ListSymbol {
            get {
                return listSymbol;
            }
        }
    
        /**
         * Return the indentation needed to show the listsymbol.
         *
         * @return    a value
         */
    
        public float ListIndent {
            get {
                return symbolIndent;
            }
        }
    
        /**
         * Get the string representation of what is in this line.
         *
         * @return    a <CODE>string</CODE>
         */
    
        public override string ToString() {
            StringBuilder tmp = new StringBuilder();
            foreach (PdfChunk c in line) {
                tmp.Append(c.ToString());
            }
            return tmp.ToString();
        }
    
        public int GetLineLengthUtf32() {
            int total = 0;
            foreach (PdfChunk c in line) {
                total += c.LengthUtf32;
            }
            return total;
        }
    
        /**
         * Checks if a newline caused the line split.
         * @return <CODE>true</CODE> if a newline caused the line split
         */
        public bool NewlineSplit {
            get {
                return newlineSplit && (alignment != Element.ALIGN_JUSTIFIED_ALL);
            }
        }
    
        /**
         * Gets the index of the last <CODE>PdfChunk</CODE> with metric attributes
         * @return the last <CODE>PdfChunk</CODE> with metric attributes
         */
        public int LastStrokeChunk {
            get {
                int lastIdx = line.Count - 1;
                for (; lastIdx >= 0; --lastIdx) {
                    PdfChunk chunk = line[lastIdx];
                    if (chunk.IsStroked())
                        break;
                }
                return lastIdx;
            }
        }
    
        /**
         * Gets a <CODE>PdfChunk</CODE> by index.
         * @param idx the index
         * @return the <CODE>PdfChunk</CODE> or null if beyond the array
         */
        public PdfChunk GetChunk(int idx) {
            if (idx < 0 || idx >= line.Count)
                return null;
            return line[idx];
        }
    
        /**
         * Gets the original width of the line.
         * @return the original width of the line
         */
        public float OriginalWidth {
            get {
                return originalWidth;
            }
        }
    
        /**
         * Gets the difference between the "normal" leading and the maximum
         * size (for instance when there are images in the chunk and the leading
         * has to be taken into account).
         * @return  an extra leading for images
         * @since   2.1.5
         */
        internal float[] GetMaxSize() {
            float normal_leading = 0;
            float image_leading = -10000;
            PdfChunk chunk;
            for (int k = 0; k < line.Count; ++k) {
                chunk = line[k];
                if (!chunk.IsImage()) {
                    normal_leading = Math.Max(chunk.Font.Size, normal_leading);
                }
                else {
                    Image img = chunk.Image;
                    if (chunk.ChangeLeading) {
                        float height = img.ScaledHeight + chunk.ImageOffsetY + img.SpacingBefore;
                        image_leading = Math.Max(height, image_leading);
                    }
                }
            }
            return new float[]{normal_leading, image_leading};
        }
    
        internal bool RTL {
            get {
                return isRTL;
            }
        }
    
        /**
        * Gets the number of separators in the line.
        * Returns -1 if there's a tab in the line.
        * @return  the number of separators in the line
        * @since   2.1.2
        */
        internal int GetSeparatorCount() {
            int s = 0;
            foreach (PdfChunk ck in line) {
                if (ck.IsTab()) {
                    return -1;
                }
                if (ck.IsHorizontalSeparator()) {
                    s++;
                }
            }
            return s;
        }

        public float GetWidthCorrected(float charSpacing, float wordSpacing) {
            float total = 0;
            for (int k = 0; k < line.Count; ++k) {
                PdfChunk ck = line[k];
                total += ck.GetWidthCorrected(charSpacing, wordSpacing);
            }
            return total;
        }

        /**
        * Gets the maximum size of the ascender for all the fonts used
        * in this line.
        * @return maximum size of all the ascenders used in this line
        */
        public float Ascender {
            get {
                float ascender = 0;
                foreach (PdfChunk ck in line) {
                    if (ck.IsImage())
                        ascender = Math.Max(ascender, ck.Image.ScaledHeight + ck.ImageOffsetY);
                    else {
                        PdfFont font = ck.Font;
                        ascender = Math.Max(ascender, font.Font.GetFontDescriptor(BaseFont.ASCENT, font.Size));
                    }
                }
                return ascender;
            }
        }

        /**
        * Gets the biggest descender for all the fonts used 
        * in this line.  Note that this is a negative number.
        * @return maximum size of all the ascenders used in this line
        */
        public float Descender {
            get {
                float descender = 0;
                foreach (PdfChunk ck in line) {
                    if (ck.IsImage())
                        descender = Math.Min(descender, ck.ImageOffsetY);
                    else {
                        PdfFont font = ck.Font;
                        descender = Math.Min(descender, font.Font.GetFontDescriptor(BaseFont.DESCENT, font.Size));
                    }
                }
                return descender;
            }
        }
    }
}
