package markup;

import base.Asserts;
import base.BaseChecker;
import base.TestCounter;
import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodHandles;
import java.lang.invoke.MethodType;
import java.util.Map;
import java.util.function.BiConsumer;
import java.util.function.Consumer;

/**
 * @author Georgiy Korneev (kgeorgiy@kgeorgiy.info)
 */
public final class MarkupTester {

    private final Map<String, String> mapping;
    private final String toString;

    private MarkupTester(
        final Map<String, String> mapping,
        final String toString
    ) {
        this.mapping = mapping;
        this.toString = toString;
    }

    public static Consumer<TestCounter> variant(
        final Consumer<Checker> checker,
        final String name,
        final Map<String, String> mapping
    ) {
        return counter ->
            test(checker).accept(
                new MarkupTester(mapping, "to" + name),
                counter
            );
    }

    public static BiConsumer<MarkupTester, TestCounter> test(
        final Consumer<Checker> tester
    ) {
        return (checker, counter) ->
            tester.accept(checker.new Checker(counter));
    }

    @Override
    public String toString() {
        return toString;
    }

    public class Checker extends BaseChecker {

        public Checker(final TestCounter counter) {
            super(counter);
        }

        private <T> MethodHandle findMethod(final T value) {
            try {
                return MethodHandles.publicLookup().findVirtual(
                    value.getClass(),
                    toString,
                    MethodType.methodType(void.class, StringBuilder.class)
                );
            } catch (final NoSuchMethodException | IllegalAccessException e) {
                throw Asserts.error(
                    "Cannot find method 'void %s(StringBuilder)' for %s",
                    toString,
                    value.getClass()
                );
            }
        }

        public <T> void test(final T value, String expectedTemplate) {
            final MethodHandle method = findMethod(value);
            for (final Map.Entry<String, String> entry : mapping.entrySet()) {
                expectedTemplate = expectedTemplate.replace(
                    entry.getKey(),
                    entry.getValue()
                );
            }

            final String expected = expectedTemplate;
            counter.println("Test " + counter.getTestNo());
            counter.test(() -> {
                final StringBuilder sb = new StringBuilder();
                try {
                    method.invoke(value, sb);
                } catch (final Throwable e) {
                    throw Asserts.error(
                        "%s(StringBuilder) for %s thrown exception: %s",
                        toString,
                        value.getClass(),
                        e
                    );
                }
                Asserts.assertEquals("Result", expected, sb.toString());
            });
        }
    }
}