package textanalyze;

import java.util.ArrayList;
import lombok.experimental.ExtensionMethod;

import static java.lang.System.out;
import static textanalyze.util.StringExtractor.extractChars;

@ExtensionMethod(Character.class)
public class TextAnalyze {

    private static final String SRC =
            " \n  Какой- нибудь нибудь  нибудь  текст, \t для примера. Или для примеров?.. " +
            "Все-таки для примера-примеры.  \n  Или даже какой-нибудь пример-примеР";

    public static void main(String[] a) {

        StringBuilder sb = new StringBuilder(100);
        LineAnalyzer lineAnalyzer = new LineAnalyzer();
        FullTextAnalyzer fullTextAnalyzer = new FullTextAnalyzer();

        for (char ch : extractChars(SRC)) {
            if (ch.isLetterOrDigit()) {
                sb.append(ch.toLowerCase());
            } else {
                if (sb.length() > 0) {
                    String word = sb.toString();
                    lineAnalyzer.put(word);
                    fullTextAnalyzer.put(word);
                    sb.setLength(0);
                }
                if (ch == '\n') {
                    lineAnalyzer.printInfo();
                    lineAnalyzer.clear();
                }
            }
        }

        if (sb.length() > 0) {
            String word = sb.toString();
            lineAnalyzer.put(word);
            fullTextAnalyzer.put(word);

            lineAnalyzer.printInfo();
        } else if (lineAnalyzer.maxLength() > 0) {
            lineAnalyzer.printInfo();
        }


        ArrayList<String> mostRepeatableWords = fullTextAnalyzer.mostRepeatableWords();

        if (mostRepeatableWords.isEmpty()) {
            out.println("Повторяющихся слов нет");
        } else {
            if (mostRepeatableWords.size() == 1) {
                out.print("Наиболее часто повторяющееся слово: ");
                out.println(mostRepeatableWords.get(0));
            } else {
                out.print("Наиболее часто повторяющееся слова: ");
                out.println(mostRepeatableWords);
            }
            out.print("Повторено: ");
            out.println(fullTextAnalyzer.maxRepeated());
        }
    }
}

package textanalyze;

import java.util.ArrayList;
import java.util.HashMap;

public abstract class Analyzer {

    protected int max;

    /** На случай если нужных слов будет несколько. */
    protected final ArrayList<String> neededWords = new ArrayList<>(1);

    protected final HashMap<String, Count> countsWords = new HashMap<>();

    /** @param word передаётся сюда в нижнем регистре */
    public abstract void put(String word);
}

package textanalyze;

import java.util.ArrayList;

public class FullTextAnalyzer extends Analyzer {

    public FullTextAnalyzer() {
        max = 1;
    }

    /** @param word передаётся сюда в нижнем регистре */
    @Override public void put(String word) {
        Count count = countsWords.get(word);
        if (count != null) {
            count.value++;

            if (count.value > max) {
                neededWords.clear();
                neededWords.add(word);
                max = count.value;
            } else if (count.value == max) {
                neededWords.add(word);
            }

        } else {
            countsWords.put(word, new Count());
        }
    }

    public ArrayList<String> mostRepeatableWords() {
        return neededWords;
    }

    public int maxRepeated() {
        return max;
    }
}

package textanalyze;

import static java.lang.System.out;

public class LineAnalyzer extends Analyzer {

    /** @param word передаётся сюда в нижнем регистре */
    @Override public void put(String word) {
        int length = word.length();

        if (length > max) {
            neededWords.clear();
            neededWords.add(word);
            max = length;

            countsWords.put(word, new Count());
            return;
        }

        if (length == max && !neededWords.contains(word)) {
            neededWords.add(word);
        }

        Count count = countsWords.get(word);
        if (count != null) {
            count.value++;
        } else {
            countsWords.put(word, new Count());
        }
    }

    public int maxLength() {
        return max;
    }

    //<editor-fold defaultstate="collapsed" desc="reuseCount">
    private int reuseCount;

    public int reuseCount() {
        return reuseCount;
    }
    //</editor-fold>

    public void clear() {
        neededWords.clear();
        countsWords.clear();
        max = 0;
        reuseCount++;
    }

    public void printInfo() {
        out.print("Строка # ");
        out.println(reuseCount);

        if (neededWords.isEmpty()) {
            out.println("Слов нет.");
        } else {
            if (neededWords.size() == 1) {
                out.print("Самое длинное слово: ");
                out.println(neededWords.get(0));
            } else {
                out.print("Самые длинные словa: ");
                out.println(neededWords);
            }

            out.print("Повторения: ");
            out.println(countsWords);
            out.println("------------------------------------------------");
        }
    }
}

package textanalyze;

public class Count {

    public int value = 1;

    @Override public String toString() {
        return Integer.toString(value);
    }
}

package textanalyze.util;

public interface Extractor<F, T> {

    T extract(F from);
}

package textanalyze.util;

import java.lang.reflect.Field;

public class StringExtractor {

    private StringExtractor() {}

    private static Extractor<String, char[]> extractor = new Extractor<String, char[]>() {
        @Override public char[] extract(String from) {
            try {
                Field field = String.class.getDeclaredField("value");
                field.setAccessible(true);
                char[] result = (char[]) field.get(from);

                extractor = new NormalExtractor(field);

                return result;
            } catch (Throwable any) {
                //<editor-fold defaultstate="collapsed" desc="dummyCopier">
                DummyCopier dummyCopier = new DummyCopier();
                extractor = dummyCopier;
                return dummyCopier.extract(from);
                //</editor-fold>
            }
        }
    };

    private static class NormalExtractor implements Extractor<String, char[]> {

        private final Field field;
        public NormalExtractor(Field field) {
            this.field = field;
        }

        @Override public char[] extract(String from) {
            try {
                return (char[]) field.get(from);
            } catch (IllegalArgumentException | IllegalAccessException reallyDoubltWhatThisWillBeThrown) {
                //<editor-fold defaultstate="collapsed" desc="dummyCopier">
                DummyCopier dummyCopier = new DummyCopier();
                extractor = dummyCopier;
                return dummyCopier.extract(from);
                //</editor-fold>
            }
        }
    }

    private static class DummyCopier implements Extractor<String, char[]> {
        @Override public char[] extract(String from) {
            return from.toCharArray();
        }
    }

    /**
     * ОСТОРОЖНО! Может привести к изменению строки (по контракту immutable объекта).
     * Возможно есть ссылки на экземпляр этой строки, там где мы не предпологали.
     */
    @Deprecated
    public static char[] extractChars(String text) {
        return extractor.extract(text);
    }
}