/*
 * [SortableQuote.java]
 *
 * Summary: Comparable to Sort quotations by author.
 *
 * Copyright: (c) 2009-2017 Roedy Green, Canadian Mind Products, http://mindprod.com
 *
 * Licence: This software may be copied and used freely for any purpose but military.
 *          http://mindprod.com/contact/nonmil.html
 *
 * Requires: JDK 1.8+
 *
 * Created with: JetBrains IntelliJ IDEA IDE http://www.jetbrains.com/idea/
 *
 * Version History:
 *  1.0 2009-01-01 initial version.
 */
package com.mindprod.htmlmacros;

import com.mindprod.common18.BigDate;
import com.mindprod.common18.ST;
import com.mindprod.entities.DeEntifyStrings;
import com.mindprod.fastcat.FastCat;
import org.jetbrains.annotations.NotNull;

import java.util.Arrays;
import java.util.Comparator;
import java.util.HashSet;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * Comparable to Sort quotations by author.
 *
 * @author Roedy Green, Canadian Mind Products
 * @version 1.0 2009-01-01 initial version.
 * File to sort contains byDate, ByWeight, ByFrequency, ByWeight
 * @since 2009
 */
class
SortableQuote implements Comparable<SortableQuote>
    {
    /**
     * Regex pattern we look for embedded in big string. By default case-sensitive.
     */
    private static final Pattern WEIGHT_FINDER = Pattern.compile( "<!--\\s+weight\\s+([0-9]+)\\s-->" );

    /**
     * Regex pattern we look for embedded in big string. By default case-sensitive.
     */
    private static final Pattern ADDED_DATE_FINDER = Pattern.compile( "<!--\\s+added\\s+([0-9][0-9][0-9][0-9]\\.[0-9][0-9]\\.[0-9][0-9])\\s-->" );

    /**
     * words ignored in sort
     */
    private static final HashSet<String> noiseWords = new HashSet<>( Arrays.asList(
            "a",
            "about",
            "as",
            "by",
            "is",
            "of",
            "the",
            "to" ) );

    private static final Pattern SPLIT_ON_SPACE = Pattern.compile( " " );

    /**
     * in lower case for sort, never displayed
     */
    final String authorGivenName;

    /**
     * in lower case for sort, newer displayed
     */
    final String authorSurname;

    /**
     * in lower case for sort, includes title between <h2></h2>
     */
    final String heading;

    /**
     * in lower case for sort, includes first part of quotation body
     */
    final String precis;

    /**
     * weight, 0 if none
     */
    final int weight;

    /**
     * bigdate ordinal
     */
    final int date;

    /**
     * in mixed case, the complete quotation including <blockquote>  and </blockquote>
     */
    final String quotation;

    /**
     * true if contains <h2></h2>
     */
    private final boolean hasTitle;

    /**
     * used to sort quotations
     *
     * @param author     the author of the quotation, parsed out.
     * @param quotation, the complete quotation including <blockquote>  and </blockquote>
     */
    SortableQuote( String author, String quotation )
        {
        // might be bible verse as author
        //  <!-- macro KJV ! Revelation 5:8 -->
        author = author.trim();
        if ( author.startsWith( "<!-- macro KJV ! " ) )
            {
            final String[] words = SPLIT_ON_SPACE.split( author );
            if ( words.length < 6 )
                {
                // mangled
                this.authorSurname = "bible";
                this.authorGivenName = "";
                }
            else
                {
                // bible
                this.authorSurname = "bible " + words[ 4 ];
                String number = words[ 5 ];
                if ( number.charAt( 1 ) == ':' )
                    {
                    number = "0" + number;
                    }
                this.authorGivenName = number;
                }
            }
        else
            {
            // not bible
            String flatAuthor = DeEntifyStrings.flattenHTML( author, ' ' ).toLowerCase().replace( '\n', ' ' ).trim();

            // chop off tail in ( .. )
            final int place = flatAuthor.indexOf( '(' );
            if ( place > 0 )
                {
                flatAuthor = flatAuthor.substring( place + 1 ).trim();
                }
            flatAuthor = ST.chopTrailingString( flatAuthor, "jr." ).trim();
            flatAuthor = ST.chopLeadingString( flatAuthor, "bishop" ).trim();
            flatAuthor = ST.chopLeadingString( flatAuthor, "captain" ).trim();
            flatAuthor = ST.chopLeadingString( flatAuthor, "dr." ).trim();
            flatAuthor = ST.chopLeadingString( flatAuthor, "pastor" ).trim();
            flatAuthor = ST.chopLeadingString( flatAuthor, "professor" ).trim();
            flatAuthor = ST.chopLeadingString( flatAuthor, "sir" ).trim();
            flatAuthor = ST.chopLeadingString( flatAuthor, "st." ).trim();
            flatAuthor = ST.chopTrailingString( flatAuthor, "iii" ).trim();
            flatAuthor = ST.chopTrailingString( flatAuthor, "jr." ).trim();
            if ( flatAuthor.contains( " of " ) )
                {
                // e.g. Xenophanes of Kolophon
                this.authorSurname = ST.firstWord( flatAuthor );
                this.authorGivenName = ST.lastWord( flatAuthor );
                }
            else
                {
                this.authorSurname = ST.chopLeadingString( ST.lastWord( flatAuthor ), "d\u2019" /* &rsquo; */ );
                this.authorGivenName = ST.firstWord( flatAuthor );
                }
            }
        this.quotation = quotation;
        // extract the header, points at <h2
        final int p1 = quotation.indexOf( "<h2" );
        if ( p1 < 0 )
            {
            this.heading = "";
            this.precis = reduce( quotation );
            }
        else
            {
            // points at > at the end of <h2...>
            final int p2 = quotation.indexOf( ">", p1 + "<h2".length() );
            if ( p2 < 0 )
                {
                this.heading = "";
                this.precis = reduce( quotation );
                }
            else
                {
                // points at </h2>
                final int p3 = quotation.indexOf( "</h2>", p2 + ">".length() );
                if ( p3 < 0 )
                    {
                    this.heading = "";
                    this.precis = reduce( quotation );
                    }
                else
                    {
                    // normal case, extract heading
                    this.heading = reduce( quotation.substring( p2 + ">".length(), p3 ) );
                    // extract the precis
                    this.precis = reduce( quotation.substring( p3 ) + "</h2>" );
                    }
                }
            }
        this.hasTitle = quotation.contains( "<h2" );
        final Matcher m1 = ADDED_DATE_FINDER.matcher( quotation );
        if ( m1.find() )
            {
            date = BigDate.toOrdinal( m1.group( 1 ) );
            }
        else
            {
            date = BigDate.NULL_ORDINAL;
            }
        final Matcher m2 = WEIGHT_FINDER.matcher( quotation );
        if ( m2.find() )
            {
            weight = Integer.parseInt( m2.group( 1 ) );
            }
        else
            {
            weight = 0;
            }
        }

    /**
     * sort my authorSurname, giveName, precis of quote.
     * Defines default the sort order for SortableQuote Objects.
     * Compare this SortableQuote with another SortableQuote.
     * Compares authorSurname then authorGivenName then precis.
     * Informally, returns (this-other) or +ve if this is more positive than other.
     *
     * @param other other SortableQuote to compare with this one
     *
     * @return +ve if this&gt;other, 0 if this==other, -ve if this&lt;other
     */
    public final int compareTo( @NotNull SortableQuote other )
        {
        final int diff = ( this.hasTitle ? 1 : 0 ) - ( other.hasTitle ? 1 : 0 );
        if ( diff != 0 )
            {
            return diff;
            }
        // ignore d' in sorting.
        final int diff1 = this.authorSurname.compareTo( other.authorSurname );
        if ( diff1 != 0 )
            {
            return diff1;
            }
        final int diff2 = this.authorGivenName.compareTo( other.authorGivenName );
        if ( diff2 != 0 )
            {
            return diff2;
            }
        int diff3 = this.heading.compareTo( other.heading );
        if ( diff3 != 0 )
            {
            return diff3;
            }
        return this.precis.compareTo( other.precis );
        }

    public String getQuotation()
        {
        return quotation;
        }

    /**
     * massage string to lower case, remove HTML, remove noise words, trim to 80 chars, to provide a precis of the quote
     *
     * @param s string
     *
     * @return tidied strin7g
     */
    public final String reduce( final String s )
        {
        String flat = DeEntifyStrings.flattenHTML( s, ' ' );
        if ( flat.length() > 80 )
            {
            flat = flat.substring( 0, 80 );
            }
        flat = ST.condense( flat ).toLowerCase();
        final String[] words = SPLIT_ON_SPACE.split( flat );
        final FastCat sb = new FastCat( words.length );
        for ( String word : words )
            {
            if ( !noiseWords.contains( word ) )
                {
                sb.append( word );
                }
            }
        return sb.toSpaceList();
        }
    }

/**
 * Sort so quotes using date  added of the quote
 * <p/>
 * Defines an alternate sort order for SortableQuote.
 */
class ByDate implements Comparator<SortableQuote>
    {
    /**
     * Sort so quotes added most recently at at the top.
     * Defines an alternate sort order for SortableQuote with JDK 1.5+ generics.
     * Compare two SortableQuote Objects.
     * Compares descending occurrences() numerically then authorSurname case sensitively then authorGivenName case
     * sensitively then precis case sensitively.
     * Informally, returns (a-b), or +ve if a sorts after b.
     * The Java source code for this Comparator was generated by the
     * Canadian Mind Products ComparatorCutter Applet at http://mindprod.com/applet/comparatorcutter.html
     *
     * @param a first SortableQuote to compare
     * @param b second SortableQuote to compare
     *
     * @return +ve if a&gt;b, 0 if a==b, -ve if a&lt;b
     */
    public final int compare( SortableQuote a, SortableQuote b )
        {
        // if contain <!-- unfeatured or  <!-- featured, sort to end.
        final int au = a.quotation.contains( "<!-- unfeatured" ) ? 1 : 0;
        final int bu = b.quotation.contains( "<!-- unfeatured" ) ? 1 : 0;
        final int diff1 = au - bu;
        if ( diff1 != 0 )
            {
            return diff1;
            }
        final int af = a.quotation.contains( "<!-- featured" ) ? 1 : 0;
        final int bf = b.quotation.contains( "<!-- featured" ) ? 1 : 0;
        final int diff2 = af - bf;
        if ( diff2 != 0 )
            {
            return diff2;
            }
        int diff3 = Integer.compare( b.date, a.date ); /* descending */
        if ( diff3 != 0 )
            {
            return diff3;
            }
        // sort long quotes to top, include <blockquote>..</blockquote>
        int diff4 = Integer.compare( b.quotation.length(), a.quotation.length() );
        if ( diff4 != 0 )
            {
            return diff4;
            }
        int diff5 = a.authorSurname.compareTo( b.authorSurname );
        if ( diff5 != 0 )
            {
            return diff5;
            }
        int diff6 = a.authorGivenName.compareTo( b.authorGivenName );
        if ( diff6 != 0 )
            {
            return diff6;
            }
        int diff7 = a.heading.compareTo( b.heading );
        if ( diff7 != 0 )
            {
            return diff7;
            }
        return a.precis.compareTo( b.precis );
        }
    }

/**
 * Sort so quotes using weight of the quote
 * <p/>
 * Defines an alternate sort order for SortableQuote.
 */
class ByWeight implements Comparator<SortableQuote>
    {
    /**
     * Sort so quotes using a given word most are at the top..
     * Defines an alternate sort order for SortableQuote with JDK 1.5+ generics.
     * Compare two SortableQuote Objects.
     * Compares descending occurrences() numerically then authorSurname case sensitively then authorGivenName case
     * sensitively then precis case sensitively.
     * Informally, returns (a-b), or +ve if a sorts after b.
     * The Java source code for this Comparator was generated by the
     * Canadian Mind Products ComparatorCutter Applet at http://mindprod.com/applet/comparatorcutter.html
     *
     * @param a first SortableQuote to compare
     * @param b second SortableQuote to compare
     *
     * @return +ve if a&gt;b, 0 if a==b, -ve if a&lt;b
     */
    public final int compare( SortableQuote a, SortableQuote b )
        {
        // ignore hasTitle
        int diff = Integer.compare( b.weight, a.weight ); /* descending */
        if ( diff != 0 )
            {
            return diff;
            }
        int diff1 = a.authorSurname.compareTo( b.authorSurname );
        if ( diff1 != 0 )
            {
            return diff1;
            }
        int diff2 = a.authorGivenName.compareTo( b.authorGivenName );
        if ( diff2 != 0 )
            {
            return diff2;
            }
        int diff3 = a.heading.compareTo( b.heading );
        if ( diff3 != 0 )
            {
            return diff3;
            }
        return a.precis.compareTo( b.precis );
        }
    }

/**
 * Sort so quotes using a given word most are at the top.
 * <p/>
 * Defines an alternate sort order for SortableQuote.
 */
class ByFrequency implements Comparator<SortableQuote>
    {
    /**
     * the word we are looking for in quotation that causes it to sort near the beginning.
     */
    private final String wordOfInterest;

    /**
     * constructor
     *
     * @param wordOfInterest word occurring in quotes we want to move to the top
     */
    public ByFrequency( final String wordOfInterest )
        {
        this.wordOfInterest = wordOfInterest.toLowerCase();
        }

    /**
     * count how many times word appears in string
     *
     * @param s    string
     * @param word of interest
     *
     * @return how many times word occurs. Will count even occurs as part of a longer word in the string.
     */
    private static int occurrences( String s, String word )
        {
        final int lw = word.length();
        int count = 0;
        for ( int i = 0; i < ( s.length() - lw ); i++ )
            {
            if ( s.substring( i, i + lw ).equals( word ) )
                {
                count++;
                }
            }
        return count;
        }

    /**
     * Sort so quotes using a given word most are at the top..
     * Defines an alternate sort order for SortableQuote with JDK 1.5+ generics.
     * Compare two SortableQuote Objects.
     * Compares descending occurrences() numerically then authorSurname case sensitively then authorGivenName case
     * sensitively then precis case sensitively.
     * Informally, returns (a-b), or +ve if a sorts after b.
     * The Java source code for this Comparator was generated by the
     * Canadian Mind Products ComparatorCutter Applet at http://mindprod.com/applet/comparatorcutter.html
     *
     * @param a first SortableQuote to compare
     * @param b second SortableQuote to compare
     *
     * @return +ve if a&gt;b, 0 if a==b, -ve if a&lt;b
     */
    public final int compare( SortableQuote a, SortableQuote b )
        {
        // ignore hasTitle
        int diff = occurrences( b.quotation.toLowerCase(), wordOfInterest ) - occurrences( a.quotation.toLowerCase(),
                wordOfInterest );
        if ( diff != 0 )
            {
            return diff;
            }
        int diff1 = a.authorSurname.compareTo( b.authorSurname );
        if ( diff1 != 0 )
            {
            return diff1;
            }
        int diff2 = a.authorGivenName.compareTo( b.authorGivenName );
        if ( diff2 != 0 )
            {
            return diff2;
            }
        int diff3 = a.heading.compareTo( b.heading );
        if ( diff3 != 0 )
            {
            return diff3;
            }
        return a.precis.compareTo( b.precis );
        }
    }

/**
 * Sort so quotes so longest quotes are at the top.
 * <p/>
 * Defines an alternate sort order for SortableQuote.
 */
class ByLength implements Comparator<SortableQuote>
    {
    /**
     * constructor
     */
    public ByLength()
        {
        }

    /**
     * Sort so quotes using a given word most are at the top..
     * Defines an alternate sort order for SortableQuote with JDK 1.5+ generics.
     * Compare two SortableQuote Objects.
     * Compares descending occurrences() numerically then authorSurname case sensitively then authorGivenName case
     * sensitively then precis case sensitively.
     * Informally, returns (a-b), or +ve if a sorts after b.
     * The Java source code for this Comparator was generated by the
     * Canadian Mind Products ComparatorCutter Applet at http://mindprod.com/applet/comparatorcutter.html
     *
     * @param a first SortableQuote to compare
     * @param b second SortableQuote to compare
     *
     * @return +ve if a&gt;b, 0 if a==b, -ve if a&lt;b
     */
    public final int compare( SortableQuote a, SortableQuote b )
        {
        // if contain <!-- unfeatured or  <!-- featured, sort to end.
        final int au = a.quotation.contains( "<!-- unfeatured" ) ? 1 : 0;
        final int bu = b.quotation.contains( "<!-- unfeatured" ) ? 1 : 0;
        final int diffu = au - bu;
        if ( diffu != 0 )
            {
            return diffu;
            }
        final int af = a.quotation.contains( "<!-- featured" ) ? 1 : 0;
        final int bf = b.quotation.contains( "<!-- featured" ) ? 1 : 0;
        final int diff = af - bf;
        if ( diff != 0 )
            {
            return diff;
            }
        // sort long quotes to top, include <blockquote>..</blockquote>
        return Integer.compare( b.quotation.length(), a.quotation.length() );
        }
    }