package com.digitalbrikes.test;

import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;

import java.io.IOException;
import java.util.Collection;
import java.util.HashSet;
import java.util.Set;

import jdepend.framework.DependencyConstraint;
import jdepend.framework.JDepend;
import jdepend.framework.JavaPackage;
import jdepend.framework.PackageFilter;


public abstract class DependencyTestBase {
    private JavaPackage thePackage;
    private JDepend analysis;
    private DependencyConstraint constraint;
    
    /**
     * Declares the package to test. The actual directory needs to be specified for
     * JDepend to analyze the classes. It could be set as a property.
     */
    protected final DependencyTestBase thisPackage() {
        final String name = packageName();
        givenAnAnalysis();
        andAConstraint();
        try {
            analysis.addDirectory("target/classes/" + name.replace(".", "/"));
        } catch (IOException e) {
            fail(e.getMessage());
        }
        thePackage = constraint.addPackage(name);
        return this;
    }
    
    /**
     * Declares dependencies. Would typically follow a call to @see(dependsOn)
     */
    public final DependencyTestBase andOn(final String string) {
        return dependsOn(string);
    }
    
    /**
     * Declares dependencies. Would typically follow a call to @see(andItShouldNotDependOn)
     */
    public final DependencyTestBase orOn(final String string) {
        return andItShouldNotDependOn(string);
    }
    
    /**
     * Declares dependencies. Would typically follow a call to @see(dependsOn) or @see(andOn)
     */
    public final DependencyTestBase andItShouldNotDependOn(final String string) {
        return dependsOn(string);
    }
    
    /**
     * Declares dependencies.
     */
    public final DependencyTestBase dependsOn(final String string) {
        return addPackage(string);
    }
    
    public final void dependsOnNothing() {
        // For syntactic sugar only.
    }
    
    protected final void assertItHasAllAndNoOtherDependencies() {
        analysis.analyze();
        
        final JavaPackage resultPackage = analysis.getPackage(thePackage.getName());
        final Collection<JavaPackage> expectedEfferents = thePackage.getEfferents();
        final Collection<JavaPackage> actualEfferents = resultPackage.getEfferents();
        final Set<JavaPackage> missingEfferents = new HashSet<JavaPackage>(expectedEfferents);
        final Set<JavaPackage> unexpectedEfferents = new HashSet<JavaPackage>(actualEfferents);
        
        missingEfferents.removeAll(actualEfferents);
        unexpectedEfferents.removeAll(expectedEfferents);
        
        assertTrue("Missing: " + toString(missingEfferents), missingEfferents.isEmpty());
        assertTrue("Unexpected: " + toString(unexpectedEfferents), unexpectedEfferents.isEmpty());
    }

    private JDepend givenAnAnalysis() {
        final PackageFilter filter = new PackageFilter();
        filter.addPackage("java.*");
        filter.addPackage("javax.*");
        
        analysis = new JDepend(filter);
        return analysis;
    }
    
    private DependencyConstraint andAConstraint() {
        constraint = new DependencyConstraint();
        return constraint;
    }
    
    private DependencyTestBase addPackage(final String string) {
        final JavaPackage pack = constraint.addPackage(string);
        thePackage.dependsUpon(pack);
        return this;
    }
    
    private String packageName() {
        return getClass().getPackage().getName();
    }
    
    private String toString(final Collection<JavaPackage> packages) {
        final StringBuilder builder = new StringBuilder("[");
        for (JavaPackage pack : packages) {
            builder.append(pack.getName());
            builder.append(",");
        }
        builder.deleteCharAt(builder.length() - 1);
        builder.append("]");
        return builder.toString();
    }
}