import java.lang.reflect.Array;

import java.nio.file.Path;

import java.util.*;

import java.util.function.Predicate;

import java.util.function.Supplier;

final class TestInstance implements ThrowingRunnable {

            if (instanceArgs != null) {

                sb.append('(').append(instanceArgs).append(')');

            }

                if (functionArgs != null) {

                    sb.append('(').append(functionArgs).append(')');

        static Builder createBuilder() {

            return new Builder();

        }

        static final class Builder implements Supplier<TestDesc> {

            private Builder() {

            }

            Builder method(Method v) {

                method = v;

                return this;

            }

            Builder ctorArgs(Object... v) {

                ctorArgs = ofNullable(v);

                return this;

            }

            Builder methodArgs(Object... v) {

                methodArgs = ofNullable(v);

                return this;

            }

            @Override

            public TestDesc get() {

                TestDesc desc = new TestDesc();

                if (method == null) {

                    desc.clazz = enclosingMainMethodClass();

                } else {

                    desc.clazz = method.getDeclaringClass();

                    desc.functionName = method.getName();

                    desc.functionArgs = formatArgs(methodArgs);

                    desc.instanceArgs = formatArgs(ctorArgs);

                }

                return desc;

            }

            private static String formatArgs(List<Object> values) {

                if (values == null) {

                    return null;

                }

                return values.stream().map(v -> {

                    if (v != null && v.getClass().isArray()) {

                        return String.format("%s(length=%d)",

                                Arrays.deepToString((Object[]) v),

                                Array.getLength(v));

                    }

                    return String.format("%s", v);

                }).collect(Collectors.joining(", "));

            }

            private static List<Object> ofNullable(Object... values) {

                List<Object> result = new ArrayList();

                for (var v: values) {

                    result.add(v);

                }

                return result;

            }

            private List<Object> ctorArgs;

            private List<Object> methodArgs;

            private Method method;

                desc.functionArgs = Stream.of(args).map(v -> {

                    if (v.getClass().isArray()) {

                        return String.format("%s(length=%d)",

                                Arrays.deepToString((Object[]) v),

                                Array.getLength(v));

                    }

                    return String.format("%s", v);

                }).collect(Collectors.joining(", "));

        private Class clazz;

        private String functionName;

        private String functionArgs;

        private String instanceArgs;

        this.testDesc = TestDesc.createBuilder().get();

        this.dryRun = false;

    TestInstance(MethodCall testBody, List<ThrowingConsumer> beforeActions,

            List<ThrowingConsumer> afterActions, boolean dryRun) {

        this.testConstructor = v -> ((MethodCall)v).newInstance();

        this.dryRun = dryRun;

    Path workDir() {

        Path result = Path.of(".");

        List<String> components = new ArrayList<>();

        String testFunctionName = functionName();

        if (testFunctionName != null) {

            components.add(testFunctionName);

        }

        if (isPrametrized()) {

            components.add(String.format("%08x", fullName().hashCode()));

        }

        if (!components.isEmpty()) {

            result = result.resolve(String.join(".", components));

        }

        return result;

    }

    boolean isPrametrized() {

        return Stream.of(testDesc.functionArgs, testDesc.instanceArgs).anyMatch(

                Objects::nonNull);

    }

        final String fullName = fullName();

            beforeActions.forEach(a -> ThrowingConsumer.toConsumer(a).accept(

                if (!dryRun) {

                    Files.createDirectories(workDir());

                    testBody.accept(testInstance);

                }

            if (!KEEP_WORK_DIR.contains(status)) {

                TKit.deleteDirectoryRecursive(workDir());

            }

    private final boolean dryRun;

    private final static Set<Status> KEEP_WORK_DIR = Functional.identity(

            () -> {

                final String propertyName = "keep-work-dir";

                Set<String> keepWorkDir = TKit.tokenizeConfigProperty(

                        propertyName);

                if (keepWorkDir == null) {

                    return Set.of(Status.Failed);

                }

                Predicate<Set<String>> isOneOf = options -> {

                    return !Collections.disjoint(keepWorkDir, options);

                };

                Set<Status> result = new HashSet<>();

                if (isOneOf.test(Set.of("pass", "p"))) {

                    result.add(Status.Passed);

                }

                if (isOneOf.test(Set.of("fail", "f"))) {

                    result.add(Status.Failed);

                }

                return Collections.unmodifiableSet(result);

            }).get();