* See the License for the specific language governing permissions and
 * limitations under the License.
 */
package gradlebuild.docs.dsl.docbook;

import java.util.HashMap;
import java.util.Map;
import java.util.regex.Pattern;

/**
 * Converts the main description of a javadoc comment into a stream of tokens.
 */
class BasicJavadocLexer implements JavadocLexer {

    private
    val taskPathReports: Map<String, List<File>>
        get() = parameters.taskPathToReports.get()

    private
    val rootBuildDir: File
        get() = parameters.rootBuildDir.get().asFile

    private
    val testPathToBinaryResultsDirs: Map<String, File>
        get() = parameters.testPathToBinaryResultsDirs.get()

    get() {
        var value: IntArray? = null
        accept(object : MemberValueVisitorAdapter() {
            override fun visitArrayMemberValue(node: ArrayMemberValue) {
                value = node.value.map { it.intValue }.toIntArray()
            }
        })
        if (value == null) throw annotationMemberValueNotFound(typeOf<IntArray>())
        return value!!
    }


internal

    }

    private class VisitorImpl extends TokenVisitor {
        private final TokenVisitor visitor;
        private final LinkedList<String> elementStack = new LinkedList<String>();
        private final Map<String, String> attributes = new HashMap<String, String>();

        public VisitorImpl(TokenVisitor visitor) {
            this.visitor = visitor;
        }

                    entryPoints.add(classDetails)
                }
            }
        }

    fun getDependencies() = classes.map { it.value.outputClassFilename to it.value.dependencies.map { it.outputClassFilename } }.toMap()
}


class ClassDetails(val outputClassName: String) {
    var visited: Boolean = false
    val dependencies: MutableSet<ClassDetails> = linkedSetOf()

    @TaskAction
    public void checkDeadLinks() {
        Map<File, List<Error>> errors = new TreeMap<>();

        getDocumentationRoot().getAsFileTree().matching(pattern -> pattern.include("**/*.adoc")).forEach(file -> {
            gatherDeadLinksInFile(file, errors);
        });
        reportErrors(errors, getReportFile().get().getAsFile());
    }

    private void reportErrors(Map<File, List<Error>> errors, File reportFile) {

    Set<CombinedInterface> getSetProp() { return null; }

    Map<CombinedInterface, JavaClassWithParameterizedTypes> getMapProp() { return null; }

    List<?> getWildcardProp() { return null; }

    List<? extends CombinedInterface> getUpperBoundProp() { return null; }

    List<? super CombinedInterface> getLowerBoundProp() { return null; }

    List<? super Set<? extends Map<?, CombinedInterface[]>>>[] getNestedProp() { return null; }

        checkNotBinaryCompatibleKotlin(
            v1 = internalSource,
            v2 = publicSource
        ).apply {
            assertHasErrors(
                *reportedMembers.map {
                    added(it.first, it.second)
                }.toTypedArray()
            )
            assertHasNoWarning()
            assertHasNoInformation()
        }
    }

    @Test

                    .associate { it.path to it.genericHtmlReports() + it.findTraceJson() }
                    .filter { it.value.isNotEmpty() }

                parameters.taskPathToReports = globalExtension.taskPathToReports.map { taskPathToReportsInExtension ->
                    (taskPathToReportsInExtension.keys + taskPathToReports.keys).associateWith {

        }

        fun assertHasErrors(vararg errors: String) {
            assertThat("Has errors", richReport.errors.map { it.message }, CoreMatchers.equalTo(errors.toList()))
        }

        fun assertHasWarnings(vararg warnings: String) {
            assertThat("Has warnings", richReport.warnings.map { it.message }, CoreMatchers.equalTo(warnings.toList()))
        }