package Torello.Java;

import java.util.function.Predicate;
import java.util.function.Function;

class VertAndHorizAbbrev
{
    static String print(
            final String    s,
            final String    hAbbrevStrInput,
            final Integer   maxLineLength,
            final Integer   maxNumLines,
            final boolean   compactConsecutiveBlankLines
        )
    {
        if (maxNumLines != null) if (maxNumLines < 3) throw new IllegalArgumentException(
            "Parameter maxNumLines has been passed [" + maxNumLines + "], but this value must " +
            "be '3' or greater"
        );

        if (
                (maxLineLength == null)
            &&  (maxNumLines == null)
            &&  (compactConsecutiveBlankLines == false)
        )

            throw new IllegalArgumentException(
                "You have passed null to parameters 'maxLineLength' and 'maxNumLines'\n" +
                "You have passed false to 'compactConsecutiveBlankLines'.\n" +
                "There is nothing for this method to do."
            );

        // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***
        // NOTE ABOUT THIS METHOD:
        // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***
        // 
        // I generally try to avoid excessive use of squiggly-braces '{' and '}'.  When for-loop
        // bodies or if-then-else are painfully-obvious, I let the "Python Mentality" take over and
        // leave them off completely.  I have never programmed in Python, but extra squiggly's whne
        // they are completely unnecessary really make the code less readable, not more.
        //
        // Java is capable of having Good / Proper / Consistent Indentation - not just Python.
        // 
        // HOWEVER - THIS ENTIRE METHOD IS ONE GIANT CONGLOMERATION OF 
        //      * for-loops
        //      * if-then-else
        // 
        // Therefore thereis a Squiggly-Brace at EVERY-SINGLE-LOCATION where one may be placed.
        // I really haven't done this anywhere in Java-HTML, except here.


        // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***
        // Initializations
        // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***

        final String[]  lines       = s.split("\n");
        final String    hAbbrevStr  = (hAbbrevStrInput == null) ? "..." : hAbbrevStrInput;

        // This makes it easier to read the if-then-else-for-loop giant-mess
        final Predicate<String> checkHorizAbbrev = (maxLineLength == null)
            ? null
            : (String line) -> line.length() > maxLineLength;

        // NOTE: This value is completely unused / discarded - exxcept in the lamda-expression
        //       directly on the next line.

        final int horizMidPoint = (maxLineLength != null)
            ? (maxLineLength / 2)
            : -1;

        // This is a little unnecessary / "overdone" - but it looks better to me
        final Function<String, String> doHorizAbbrev = (maxLineLength == null)
            ? null
            : (String line) -> Abbrev.print1(line, horizMidPoint, false, hAbbrevStr, maxLineLength);


        // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***
        // If Requested, Compact Consecutive Blank-Lines First
        // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***
        //
        // MAJOR NOTE: When String.split("\n") is called, NONE OF THE RETURNED STRING'S for the
        //             String[] will actually be Java-String's with any newlines in them!!
        // 
        // IN OTHER WORDS: String.split("\n"), does INDEED remove all newlines from the output
        //                 array!

        int insertPos = 0;

        if (compactConsecutiveBlankLines)
        {
            int     curBlankCount   = 0;
            int     sourcePos       = 0;

            while (sourcePos < lines.length)
            {
                final String line = lines[sourcePos++];

                if (line.trim().length() == 0) curBlankCount++;

                else 
                {
                    if (curBlankCount > 1)
                        // REMEMBER NOT TO APPEND A NEW-LINE AT THE END OF THIS STRING
                        lines[insertPos++] = "[Compacted " + curBlankCount + " Blank Lines]";

                    else if (curBlankCount == 1)
                        // AND, FURTHERMORE, THIS STRING IS JUST A ZERO-LENGTH-STRING
                        // lines[insertPos++] = '[' + lines[sourcePos-1] + ']';
                        // NOTE: When debugging, use the brackets, above, it helps

                        lines[insertPos++] = lines[sourcePos-1];

                    curBlankCount = 0;

                    // add the line, and when debugging, make sure to keep the brackets
                    // lines[insertPos++] = '[' + line + ']';

                    lines[insertPos++] = line;
                }
            }


            // Possible "Trailing Stack of Blank Lines" (which never got a "Compacted Notice"
            // because the loop terminatd before one could be appended)
            // 
            // ONCE-AGAIN: Anytime **ANYTHING** has any amount of "parse" whatsoever, there will
            //             **ALWAYS** be a Trailing-Read where the last "chunk" of the String, 
            //             (or in this case, the String[]-Array) need to be run through whatever
            //             test was going-on inside the loop.

            if (curBlankCount > 1)
                lines[insertPos++] = "[Compacted " + curBlankCount + " Blank Lines]";

            else if (curBlankCount == 1)
                lines[insertPos++] = "";
        }


        // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***
        // NOW DO THE COMPACTING - THERE ARE 4 DIFFERENT CASES.
        // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***
        // 
        // Horizontal-Abbreviation-Requested: true | false
        // Vertical-Abbreviation-Required:    true | false


        // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***
        // VERSION #1: Number of Lines (VERTICAL) is **LESS THAN** 'maxNumLines'
        // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***

        final StringBuilder sb          = new StringBuilder();
        final int           LEN         = compactConsecutiveBlankLines ? insertPos : lines.length;
        final boolean       COMPACTED   = (LEN < lines.length);  // Needed for minor optimization

        if ((maxNumLines == null) || (LEN <= maxNumLines)) // VERTICAL-NOT-REQUIRED
        {
            // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***
            // Version 1A: "Max-Line-Length" (HORIZONTAL) has an actual, non-null, value.
            // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***
            //
            // NOTE - THAT RIGHT HERE - IT HAS ALREADY BEEN ESTABLISHED:
            //        LEN <= maxNumLines  **OR**  maxNumLines==null (unlimited-vertical)
            //        ==> NO VERTICAL ABBREVIATION

            if (maxLineLength != null) // HORIZONTAL-REQUESTED
            {
                for (int pos=0; pos < LEN; pos++)
                {
                    String line = lines[pos];


                    // Again, the "Check if Horizontal-Abbreviation is necessary" check
                    // was actually turned into a Predicate, solely, to make this part of the
                    // code more readable/intelligble.  (as was the Abbrev-Call turned into a
                    // Java-Function-Pointer-Lambda thingy)

                    if (checkHorizAbbrev.test(line)) line = doHorizAbbrev.apply(line);

                    // HERE - AND ONLY HERE - IS AN ACTUAL NEW-LINE APPENDED
                    sb.append(line);

                    // Do not add the VERY-LAST-NEWLINE, it isn't needed.
                    if (pos < (LEN-1)) sb.append('\n');
                }
            }


            // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***
            // Version 1B: "Max-Line-Length" (HORIZONTAL) was passed null (NO HORIZONTAL ABBREV)
            // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***
            //
            // NOTE - THAT RIGHT HERE - IT HAS ALREADY BEEN ESTABLISHED:
            //        LEN <= maxNumLines  **OR**  maxNumLines==null (unlimited-vertical)
            //        ==> NO VERTICAL ABBREVIATION

            else // HORIZONTAL-NOT-REQUESTED
            {
                // IMPORTANT POINT TO KEEP IN MIND: Even though NEITHER Horizontal NOR Vertical
                // abbreviation is needed - the user may still have asked that blank lines have 
                // been compacted, so we may as well check for that.
                // 
                // If Horizontal, Vertical and Blank-Line-Compaction are all "false", we can just
                // return the original String 's'

                if (! COMPACTED) return s;

                else for (int pos=0; pos < LEN; pos++)
                {
                    // HERE - AND ONLY HERE - IS AN ACTUAL NEW-LINE APPENDED
                    sb.append(lines[pos]);

                    // Do not add the VERY-LAST-NEWLINE, it isn't needed.
                    if (pos < (LEN-1)) sb.append('\n');
                }
            }

            return sb.toString();
        }


        // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***
        // OTHERWISE - VERSION #2: Number of Lines (VERTICAL) is **GREATER THAN** 'maxNumLines'
        // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***
        // 
        // maxNumLines is not null at this point, otherewise the if-statement way above this line
        // would have already succeeded, and the method would already have returned.

        final int verticalMidPoint = maxNumLines / 2;

        if (maxLineLength != null) // HORIZONTAL-REQUESTED
        {
            // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***
            // Version 2A: "Max-Line-Length" (HORIZONTAL) has an actual, non-null, value.
            // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***
            //
            // NOTE, THAT RIGHT HERE IT HAS ALREADY BEEN ESTABLISHED: LEN > maxNumLines
            //       ==> VERTICAL ABBREVIATION REQUIRED

            for (int pos=0; pos < LEN; pos++)
            {
                if (pos == verticalMidPoint)
                {
                    sb.append("[Text Shortened by " + (lines.length - LEN) + " Line(s)]\n");
                    pos = lines.length - verticalMidPoint - 1;
                }    
  
                else
                {
                    String line = lines[pos];
                    if (checkHorizAbbrev.test(line)) line = doHorizAbbrev.apply(line);
    
                    // HERE - AND ONLY HERE - IS AN ACTUAL NEW-LINE APPENDED
                    sb.append(line);

                    // Do not add the VERY-LAST-NEWLINE, it isn't needed.
                    if (pos < (LEN-1)) sb.append('\n');
                }
            }
        }

        else // HORIZONTAL-NOT-REQUESTED
        {
            // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***
            // Version 2B: "Max-Line-Length" (HORIZONTAL) was passed null - NO HORIZONTAL ABBREV
            // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***
            //
            // NOTE, THAT RIGHT HERE IT HAS ALREADY BEEN ESTABLISHED: LEN > maxNumLines
            //       ==> VERTICAL ABBREVIATION REQUIRED

            for (int pos=0; pos < LEN; pos++)
            {
                if (pos == verticalMidPoint)
                {
                    sb.append("[Text Shortened by " + (lines.length - LEN) + " Line(s)]\n");
                    pos = lines.length - verticalMidPoint;
                }

                else
                {
                    // HERE - AND ONLY HERE - IS AN ACTUAL NEW-LINE APPENDED
                    sb.append(lines[pos]);

                    // Do not add the VERY-LAST-NEWLINE, it isn't needed.
                    if (pos < (LEN-1)) sb.append('\n');
                }
            }
        }

        return sb.toString();
    }
}