// Copyright 2007, 2013 The Apache Software Foundation
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package org.apache.tapestry5.test;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.*;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;

/**
 * Provides access to random data that can be used when populating a test database with "reasonable" data. The majority
 * of this is access to random words from an american english dictionary, which can be strung together to form names,
 * sentences and paragraphs.
 */
public final class RandomDataSource
{
    private static final Logger LOGGER = LoggerFactory.getLogger(RandomDataSource.class);

    private final Random random = new Random(System.currentTimeMillis());

    private final static List<String> words = new ArrayList<String>();

    private static void loadWords()
    {
        if (words.isEmpty())
        {

            for (int i = 0; i < 4; i++)
                readWords("english." + i);

            for (int i = 0; i < 3; i++)
                readWords("american." + i);

            LOGGER.info(String.format("Dictionary contains %,d words.", words.size()));
        }
    }

    private static void readWords(String name)
    {
        LOGGER.info("Reading {} ...", name);

        int count = 0;

        InputStream is = RandomDataSource.class.getResourceAsStream(name);

        if (is == null) throw new RuntimeException(String.format("File '%s' not found.", name));

        try
        {
            BufferedInputStream bis = new BufferedInputStream(is);
            InputStreamReader isr = new InputStreamReader(bis);
            LineNumberReader r = new LineNumberReader(isr);

            while (true)
            {
                String word = r.readLine();

                if (word == null) break;

                count++;
                words.add(word);
            }

            r.close();
        } catch (IOException ex)
        {
            throw new RuntimeException(String.format("Error reading '%s': %s", name + ex.getMessage()), ex);
        }

        LOGGER.info(String.format("... %,d words", count));
    }

    public boolean maybe(int percent)
    {
        assert percent > 0 && percent <= 100;

        return random.nextInt(100) < percent;
    }

    public int random(int min, int max)
    {
        assert min <= max;

        return random.nextInt(max - min + 1) + min;
    }

    /**
     * Returns a random word frm the dictionary. These words are usually all lowercase.
     */
    public String word()
    {
        loadWords();

        int index = random.nextInt(words.size());

        return words.get(index);
    }

    /**
     * Returns a random word, capitalized. Useful when create random names.
     */
    public String capitalizedWord()
    {
        String word = word();

        char[] chars = word.toCharArray();

        chars[0] = Character.toUpperCase(chars[0]);

        return new String(chars);
    }

    /**
     * Returns a word that is "safe" for use in an email address.
     */
    public String safeWord()
    {
        String word = word();

        int x = word.indexOf('\'');

        return x < 0 ? word : word.substring(0, x);
    }

    /**
     * Returns a random value from the list of values supplied.
     */
    public <T> T oneOf(T... values)
    {
        assert values.length > 0;

        int index = random.nextInt(values.length);

        return values[index];
    }

    /**
     * Returns a random enum value, given the enum type.
     */
    public <T extends Enum> T oneOf(Class<T> enumClass)
    {
        return oneOf(enumClass.getEnumConstants());
    }

    /**
     * Creates a space-separated list of random words. If in sentence form, then the first word is capitalized, and a
     * period is appended.
     *
     * @param minWords
     *         minimun number of words in the list
     * @param maxWords
     *         maximum number of words in the list
     * @param asSentence
     *         if true, the output is "dressed up" as a non-sensical sentence
     * @return the word list / sentence
     */
    public String wordList(int minWords, int maxWords, boolean asSentence)
    {
        assert minWords <= maxWords;
        assert minWords > 0;

        StringBuilder builder = new StringBuilder();

        int count = random(minWords, maxWords);

        for (int i = 0; i < count; i++)
        {

            if (i > 0) builder.append(' ');

            if (i == 0 && asSentence)
                builder.append(capitalizedWord());
            else
                builder.append(word());
        }

        if (asSentence) builder.append('.');

        return builder.toString();
    }

    /**
     * Strings together a random number of word lists (in sentence form) to create something that looks like a
     * paragraph.
     *
     * @param minSentences
     *         per paragraph
     * @param maxSentences
     *         per paragraph
     * @param minWords
     *         per sentence
     * @param maxWords
     *         per sentence
     * @return the random paragraph
     */
    public String paragraph(int minSentences, int maxSentences, int minWords, int maxWords)
    {
        assert minSentences < maxSentences;
        assert minSentences > 0;

        int count = random(minSentences, maxSentences);

        StringBuilder builder = new StringBuilder();

        for (int i = 0; i < count; i++)
        {
            if (i > 0) builder.append(' ');

            builder.append(wordList(minWords, maxWords, true));
        }

        return builder.toString();
    }
}