package com.temp.shared.utils;

public class SafeHtmlizer {

    public static SafeHtmlizer getInstance() {
        SafeHtmlizer zInstance = sInstance; // Snag the reference
        // If null then Force Registration
        return (zInstance != null) ? zInstance : new SafeHtmlizer();
    }

    public static final String HTML_BR = "<br />";

    public static final String CRNL = "\r\n";

    /**
     * HTML Encode the first line of the input (guaranteed to contains at least
     * a single character).
     * <p/>
     * <ul>
     * <li>Line Breaks are normalized to NewLines. (@see normalizeNewLines)</li>
     * <li>Tabs are converted to a space. (@see tabsToSpaces)</li>
     * <li>Leading blank lines are removed. (@see eliminateLeadingEmptyLines)</li>
     * <li>Escape the HTML Markup and sanitize the text (@see escapeAndSanitize)
     * </li>
     * </ul>
     *
     * @param pText String to be processed.
     *
     * @return Processed pText.
     */
    public String noEmpty1stLine( String pText ) {
        return escapeAndSanitize( HtmlEntity.NBSP, insureNotEmpty(
                only1stLine( eliminateLeadingEmptyLines( tabsToSpaces( normalizeNewLines( StringUtils.deNull( pText ) ) ) ) ) ) );
    }

    /**
     * HTML Encode the input (guaranteed to contains at least a single
     * character) with New Lines converted to &lt;br /&gt;s.
     * <p/>
     * <ul>
     * <li>Line Breaks are normalized to NewLines. (@see normalizeNewLines)</li>
     * <li>Tabs are converted to a space. (@see tabsToSpaces)</li>
     * <li>Leading blank lines are removed. (@see eliminateLeadingEmptyLines)</li>
     * <li>Escape the HTML Markup and sanitize the text (@see escapeAndSanitize)
     * </li>
     * </ul>
     *
     * @param pText String to be processed.
     *
     * @return Processed pText.
     */
    public String noEmpty( String pText ) {
        return escapeAndSanitize( HtmlEntity.NBSP,
                                  insureNotEmpty( eliminateLeadingEmptyLines( tabsToSpaces( normalizeNewLines( StringUtils.deNull( pText ) ) ) ) ) );
    }

    /**
     * HTML Encode the input (guaranteed to contains at least a single
     * character) with New Lines converted to &lt;br /&gt;s.
     * <p/>
     * <ul>
     * <li>Line Breaks are normalized to NewLines. (@see normalizeNewLines)</li>
     * <li>Tabs are converted to a space. (@see tabsToSpaces)</li>
     * <li>Leading blank lines are removed. (@see eliminateLeadingEmptyLines)</li>
     * <li>Escape the HTML Markup and sanitize the text (@see escapeAndSanitize)
     * </li>
     * </ul>
     *
     * @param pText String to be processed.
     *
     * @return Processed pText.
     */
    public String noEmptyLeaveSomeSpaces( String pText ) {
        return escapeAndSanitize( " ", insureNotEmpty( eliminateLeadingEmptyLines( tabsToSpaces( normalizeNewLines( StringUtils.deNull( pText ) ) ) ) ) );
    }

    /**
     * HTML Encode the input (guaranteed to contains at least a single
     * character) with New Lines converted to &lt;br /&gt;s.
     * <p/>
     * <ul>
     * <li>Line Breaks are normalized to NewLines. (@see normalizeNewLines)</li>
     * <li>Tabs are converted to a space. (@see tabsToSpaces)</li>
     * <li>Leading blank lines are removed. (@see eliminateLeadingEmptyLines)</li>
     * <li>Lines are Force Wrapped if they exceed the MaxCharactersPerLine.
     * (@see enforceMaxCharactersPerLine)</li>
     * <li>Escape the HTML Markup and sanitize the text (@see escapeAndSanitize)
     * </li>
     * </ul>
     *
     * @param pText                 String to be processed.
     * @param pMaxCharactersPerLine Will inject new lines if any line exceeds this length
     *
     * @return Processed pText.
     */
    public String noEmpty( String pText, int pMaxCharactersPerLine ) {
        return escapeAndSanitize( HtmlEntity.NBSP, enforceMaxCharactersPerLine(
                insureNotEmpty( eliminateLeadingEmptyLines( tabsToSpaces( normalizeNewLines( StringUtils.deNull( pText ) ) ) ) ), pMaxCharactersPerLine ) );
    }

    /**
     * Inject NewLines where ever the line length exceeds the
     * MaxCharactersPerLine.
     *
     * @param pText                 !null
     * @param pMaxCharactersPerLine Max characters per line, with a floor of 40.
     */
    protected String enforceMaxCharactersPerLine( String pText, int pMaxCharactersPerLine ) {
        return StringUtils.wrap( pText, (pMaxCharactersPerLine < 40) ? 40 : pMaxCharactersPerLine );
    }

    /**
     * Line Breaks are normalized to NewLines. (after CR LF combinations are
     * converted to a LF, then both FFs & CRs are converted to LFs).
     *
     * @param pText !null
     */
    protected String normalizeNewLines( String pText ) {
        // switch "CR LF" -> LF & then switch CR -> LF & then switch FF -> LF
        return convertCRNL( pText ).replace( '\r', '\n' ).replace( '\f', '\n' );
    }

    /**
     * Tabs are converted to a space.
     *
     * @param pText !null
     */
    protected String tabsToSpaces( String pText ) {
        return pText.replace( '\t', ' ' );
    }

    /**
     * Leading blank lines are removed.
     *
     * @param pText !null
     */
    protected String eliminateLeadingEmptyLines( String pText ) {
        Integer justPastNewLine = null;
        int at = 0;
        while ( at < pText.length() ) {
            char c = pText.charAt( at++ );
            if ( c != ' ' ) // Leading whitespace
            {
                if ( c != '\n' ) {
                    break;
                }
                justPastNewLine = at;
            }
        }
        return (justPastNewLine == null) ? pText : pText.substring( justPastNewLine );
    }

    /**
     * Return the Text if no New Lines, otherwise return the Text upto the first
     * New Line.
     *
     * @param pText !null
     */
    protected String only1stLine( String pText ) {
        int at = pText.indexOf( '\n' );
        return (at == -1) ? pText : pText.substring( 0, at );
    }

    /**
     * Return the text unless it is empty, then return a space.
     *
     * @param pText !null
     */
    protected String insureNotEmpty( String pText ) {
        return pText.isEmpty() ? " " : pText;
    }

    /**
     * Convert CR LF (New Line) combinations into just a LF.
     *
     * @param pText !null
     */
    protected String convertCRNL( String pText ) {
        int at = pText.indexOf( CRNL );
        if ( at == -1 ) {
            return pText;
        }
        StringBuilder sb = new StringBuilder( pText );
        do {
            sb.deleteCharAt( at );
        } while ( -1 != (at = pText.indexOf( CRNL )) );
        return sb.toString();
    }

    /**
     * Escape and sanitize the text to make if reasonably safe to inject as HTML for display purposes.
     * <p/>
     * This means that in addition to escaping the standard html special characters ('"', '<', '>', '&'),
     * blah blah blah are decimal escaped to eliminate "cdata" sections,
     * spaces are converted to "&nbsp;", New Lines are converted to "<br />", all other control characters
     * are converted to a period ('.'), and any remaining non-7Bit ascii is turned into a decimal entity.
     *
     * @param spaceReplacement !null
     * @param pText            !null
     *
     * @return Processed pText.
     */
    protected String escapeAndSanitize( String spaceReplacement, String pText ) {
        StringBuilder sb = new StringBuilder();
        for ( int i = 0; i < pText.length(); ) {
            char c = pText.charAt( i++ );
            switch ( c ) {
                case 160: // Hi-bit Space
                case ' ':
                    sb.append( isSpace( getCharacterAt( pText, i ) ) ? HtmlEntity.NBSP : spaceReplacement );
                    break;
                case '&':
                    sb.append( HtmlEntity.AMP.getString() );
                    break;
                case '<':
                    sb.append( HtmlEntity.LT.getString() );
                    break;
                case '>':
                    sb.append( HtmlEntity.GT.getString() );
                    break;
                case '"':
                    sb.append( HtmlEntity.QUOT.getString() );
                    break;
                case '\n':
                    sb.append( HTML_BR );
                    break;
                default:
                    if ( (c < ' ') || ((127 <= c) && (c < 160)) ) // Control
                    // Character
                    {
                        sb.append( '.' );
                        break;
                    }
                    if ( c < 127 ) // Regular 7-bit Ascii
                    {
                        sb.append( c );
                        break;
                    }
                    // Decimal Escape It!
                    sb.append( "&#" );
                    sb.append( (int) c );
                    sb.append( ';' );
                    break;
            }
        }
        return sb.toString();
    }

    private boolean isSpace( Character character ) {
        if ( character != null ) {
            char c = character.charValue();
            return (c == ' ') || (c == 160); // Hi-Bit Space
        }
        return false;
    }

    private Character getCharacterAt( String text, int at ) {
        if ( at < text.length() ) {
            return text.charAt( at );
        }
        return null;
    }

    private static volatile SafeHtmlizer sInstance;

    protected SafeHtmlizer() {
        sInstance = this;
    }
}