/*
 *  Licensed to the Apache Software Foundation (ASF) under one or more
 *  contributor license agreements.  See the NOTICE file distributed with
 *  this work for additional information regarding copyright ownership.
 *  The ASF licenses this file to You 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.ivy.osgi.p2;

import java.io.IOException;
import java.io.InputStream;
import java.net.URI;
import java.net.URISyntaxException;
import java.text.ParseException;
import java.util.ArrayList;
import java.util.List;

import javax.xml.parsers.ParserConfigurationException;

import org.apache.ivy.osgi.core.BundleCapability;
import org.apache.ivy.osgi.core.BundleInfo;
import org.apache.ivy.osgi.core.BundleRequirement;
import org.apache.ivy.osgi.core.ExportPackage;
import org.apache.ivy.osgi.core.ManifestParser;
import org.apache.ivy.osgi.p2.PropertiesParser.PropertiesHandler;
import org.apache.ivy.osgi.util.DelegatingHandler;
import org.apache.ivy.osgi.util.Version;
import org.apache.ivy.osgi.util.VersionRange;
import org.apache.ivy.util.Message;
import org.apache.ivy.util.XMLHelper;
import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.SAXParseException;

public class P2MetadataParser implements XMLInputParser {

    private final P2Descriptor p2Descriptor;

    private int logLevel = Message.MSG_INFO;

    public P2MetadataParser(P2Descriptor p2Descriptor) {
        this.p2Descriptor = p2Descriptor;
    }

    public void setLogLevel(int logLevel) {
        this.logLevel = logLevel;
    }

    public void parse(InputStream in) throws IOException, ParseException, SAXException {
        RepositoryHandler handler = new RepositoryHandler(p2Descriptor);
        try {
            XMLHelper.parse(in, null, handler, null);
        } catch (ParserConfigurationException e) {
            throw new SAXException(e);
        }
    }

    private class RepositoryHandler extends DelegatingHandler {

        // private static final String P2_TIMESTAMP = "p2.timestamp";

        private static final String REPOSITORY = "repository";

        // private static final String NAME = "name";
        //
        // private static final String TYPE = "type";
        //
        // private static final String VERSION = "version";
        //
        // private static final String DESCRIPTION = "description";
        //
        // private static final String PROVIDER = "provider";

        public RepositoryHandler(final P2Descriptor p2Descriptor) {
            super(REPOSITORY);
            // addChild(new PropertiesHandler(P2_TIMESTAMP),
            // new ChildElementHandler<PropertiesHandler>() {
            // public void childHandled(PropertiesHandler child) {
            // String timestamp = child.properties.get(P2_TIMESTAMP);
            // if (timestamp != null) {
            // p2Descriptor.setTimestamp(Long.parseLong(timestamp));
            // }
            // }
            // });
            addChild(new UnitsHandler(), new ChildElementHandler<UnitsHandler>() {
                @Override
                public void childHandled(UnitsHandler child) {
                    for (BundleInfo bundle : child.bundles) {
                        p2Descriptor.addBundle(bundle);
                    }
                }
            });
            addChild(new ReferencesHandler(), new ChildElementHandler<ReferencesHandler>() {
                @Override
                public void childHandled(ReferencesHandler child) {
                }
            });
        }

        // protected void handleAttributes(Attributes atts) {
        // String name = atts.getValue(NAME);
        // String type = atts.getValue(TYPE);
        // String version = atts.getValue(VERSION);
        // String description = atts.getValue(DESCRIPTION);
        // String provider = atts.getValue(PROVIDER);
        // }
    }

    private class ReferencesHandler extends DelegatingHandler {

        private static final String REFERENCES = "references";

        private static final String SIZE = "size";

        List<URI> repositoryUris;

        public ReferencesHandler() {
            super(REFERENCES);
            addChild(new RepositoryReferenceHandler(),
                new ChildElementHandler<RepositoryReferenceHandler>() {
                    @Override
                    public void childHandled(RepositoryReferenceHandler child) {
                        repositoryUris.add(child.uri);
                    }
                });
        }

        @Override
        protected void handleAttributes(Attributes atts) throws SAXException {
            int size = Integer.parseInt(atts.getValue(SIZE));
            repositoryUris = new ArrayList<>(size);
        }
    }

    private class RepositoryReferenceHandler extends DelegatingHandler {

        private static final String REPOSITORY = "repository";

        // private static final String TYPE = "type";
        //
        // private static final String OPTIONS = "options";
        //
        // private static final String NAME = "name";

        private static final String URI = "uri";

        private static final String URL = "url";

        public RepositoryReferenceHandler() {
            super(REPOSITORY);
        }

        // int type;
        //
        // int options;
        //
        // String name;

        URI uri;

        @Override
        protected void handleAttributes(Attributes atts) throws SAXException {
            // type = Integer.parseInt(atts.getValue(TYPE));
            // options = Integer.parseInt(atts.getValue(OPTIONS));
            // name = atts.getValue(NAME);

            String uriAtt = atts.getValue(URI);
            String urlAtt = atts.getValue(URL);

            if (uriAtt != null) {
                try {
                    uri = new URI(uriAtt);
                } catch (URISyntaxException e) {
                    throw new SAXParseException("Invalid uri attribute " + uriAtt + "("
                            + e.getMessage() + ")", getLocator());
                }
            }
            if (uri != null && urlAtt != null) {
                try {
                    uri = new URI(urlAtt);
                } catch (URISyntaxException e) {
                    throw new SAXParseException("Invalid url attribute " + urlAtt + "("
                            + e.getMessage() + ")", getLocator());
                }
            }
        }
    }

    private class UnitsHandler extends DelegatingHandler {

        private static final String UNITS = "units";

        private static final String SIZE = "size";

        List<BundleInfo> bundles;

        public UnitsHandler() {
            super(UNITS);
            addChild(new UnitHandler(), new ChildElementHandler<UnitHandler>() {
                @Override
                public void childHandled(UnitHandler child) {
                    if (child.bundleInfo != null && !child.bundleInfo.getCapabilities().isEmpty()) {
                        bundles.add(child.bundleInfo);
                    }
                }
            });
        }

        @Override
        protected void handleAttributes(Attributes atts) {
            int size = Integer.parseInt(atts.getValue(SIZE));
            bundles = new ArrayList<>(size);
        }

    }

    class UnitHandler extends DelegatingHandler {

        private static final String CATEGORY_PROPERTY = "org.eclipse.equinox.p2.type.category";

        private static final String UNIT = "unit";

        private static final String ID = "id";

        private static final String VERSION = "version";

        // private static final String SINGLETON = "singleton";

        BundleInfo bundleInfo;

        public UnitHandler() {
            super(UNIT);
            // addChild(new UpdateHandler(), new ChildElementHandler() {
            // public void childHandled(DelegatingHandler child) {
            // }
            // });
            addChild(new PropertiesHandler(CATEGORY_PROPERTY),
                new ChildElementHandler<PropertiesHandler>() {
                    @Override
                    public void childHandled(PropertiesHandler child) {
                        String category = child.properties.get(CATEGORY_PROPERTY);
                        if (category != null && Boolean.valueOf(category)) {
                            // this is a category definition, this is useless, skip this unit
                            child.getParent().skip();
                            bundleInfo = null;
                        }
                    }
                });
            addChild(new ProvidesHandler(), new ChildElementHandler<ProvidesHandler>() {
                @Override
                public void childHandled(ProvidesHandler child) {
                    if ("source".equals(child.eclipseType)) {
                        // this is some source of some bundle
                        bundleInfo.setSource(true);
                        // we need to parse the manifest in the touchpointData to figure out the
                        // targeted bundle
                        // in case we won't have the proper data in the manifest, prepare the source
                        // data from the convention
                        String symbolicName = bundleInfo.getSymbolicName();
                        if (symbolicName.endsWith(".source")) {
                            bundleInfo.setSymbolicNameTarget(symbolicName.substring(0,
                                symbolicName.length() - 7));
                            bundleInfo.setVersionTarget(bundleInfo.getVersion());
                        }
                    }
                    for (BundleCapability capability : child.capabilities) {
                        bundleInfo.addCapability(capability);
                    }
                }
            });
            addChild(new FilterHandler(), new ChildElementHandler<FilterHandler>() {
                @Override
                public void childHandled(FilterHandler child) {
                }
            });
            addChild(new RequiresHandler(), new ChildElementHandler<RequiresHandler>() {
                @Override
                public void childHandled(RequiresHandler child) {
                    for (BundleRequirement requirement : child.requirements) {
                        bundleInfo.addRequirement(requirement);
                    }
                }
            });
            addChild(new HostRequirementsHandler(),
                new ChildElementHandler<HostRequirementsHandler>() {
                    @Override
                    public void childHandled(HostRequirementsHandler child) {
                    }
                });
            addChild(new MetaRequirementsHandler(),
                new ChildElementHandler<MetaRequirementsHandler>() {
                    @Override
                    public void childHandled(MetaRequirementsHandler child) {
                    }
                });
            addChild(new ArtifactsHandler(), new ChildElementHandler<ArtifactsHandler>() {
                @Override
                public void childHandled(ArtifactsHandler child) {
                }
            });
            // addChild(new TouchpointHandler(), new ChildElementHandler() {
            // public void childHandled(DelegatingHandler child) {
            // }
            // });
            addChild(new TouchpointDataHandler(), new ChildElementHandler<TouchpointDataHandler>() {
                @Override
                public void childHandled(TouchpointDataHandler child) throws SAXParseException {
                    if (child.zipped != null) {
                        bundleInfo.setHasInnerClasspath(child.zipped);
                    }
                    if (!bundleInfo.isSource()) {
                        // we only care about parsing the manifest if it is a source
                        return;
                    }
                    if (child.manifest != null) {
                        // Eclipse may have serialized a little bit weirdly
                        String manifest = ManifestParser.formatLines(child.manifest.trim());
                        BundleInfo embeddedInfo;
                        try {
                            embeddedInfo = ManifestParser.parseManifest(manifest);
                        } catch (IOException e) {
                            if (logLevel >= Message.MSG_VERBOSE) {
                                Message.verbose(
                                    "The Manifest of the source bundle "
                                            + bundleInfo.getSymbolicName() + " could not be parsed",
                                    e);
                            }
                            return;
                        } catch (ParseException e) {
                            if (logLevel >= Message.MSG_VERBOSE) {
                                Message.verbose(
                                    "The Manifest of the source bundle "
                                            + bundleInfo.getSymbolicName() + " is ill formed", e);
                            }
                            return;
                        }
                        if (!embeddedInfo.isSource()) {
                            if (logLevel >= Message.MSG_VERBOSE) {
                                Message.verbose("The Manifest of the source bundle "
                                        + bundleInfo.getSymbolicName()
                                        + " is not declaring being a source.");
                            }
                            return;
                        }
                        String symbolicNameTarget = embeddedInfo.getSymbolicNameTarget();
                        if (symbolicNameTarget == null) {
                            if (logLevel >= Message.MSG_VERBOSE) {
                                Message.verbose("The Manifest of the source bundle "
                                        + bundleInfo.getSymbolicName()
                                        + " is not declaring a target symbolic name.");
                            }
                            return;
                        }
                        Version versionTarget = embeddedInfo.getVersionTarget();
                        if (versionTarget == null) {
                            if (logLevel >= Message.MSG_VERBOSE) {
                                Message.verbose("The Manifest of the source bundle "
                                        + bundleInfo.getSymbolicName()
                                        + " is not declaring a target version.");
                            }
                            return;
                        }
                        bundleInfo.setSymbolicNameTarget(symbolicNameTarget);
                        bundleInfo.setVersionTarget(versionTarget);
                    }
                }
            });
            // addChild(new LicensesHandler(), new ChildElementHandler() {
            // public void childHandled(DelegatingHandler child) {
            // }
            // });
            // addChild(new CopyrightHandler(), new ChildElementHandler() {
            // public void childHandled(DelegatingHandler child) {
            // }
            // });
            // addChild(new ChangesHandler(), new ChildElementHandler() {
            // public void childHandled(DelegatingHandler child) {
            // }
            // });

        }

        @Override
        protected void handleAttributes(Attributes atts) throws SAXException {
            String id = atts.getValue(ID);
            String version = atts.getValue(VERSION);
            // Boolean singleton = Boolean.valueOf(atts.getValue(SINGLETON));
            bundleInfo = new BundleInfo(id, new Version(version));
        }

    }

    // static class UpdateHandler extends DelegatingHandler {
    //
    // private static final String UPDATE = "update";
    //
    // private static final String ID = "id";
    //
    // private static final String RANGE = "range";
    //
    // private static final String SEVERITY = "severity";
    //
    // public UpdateHandler() {
    // super(UPDATE);
    // }
    //
    // protected void handleAttributes(Attributes atts) {
    // String id = atts.getValue(ID);
    // String range = atts.getValue(RANGE);
    // String severity = atts.getValue(SEVERITY);
    // }
    //
    // }

    private static class FilterHandler extends DelegatingHandler {

        private static final String FILTER = "filter";

        public FilterHandler() {
            super(FILTER);
            setBufferingChar(true);
        }

    }

    private static String namespace2Type(String namespace) {
        if (namespace == null) {
            return null;
        }
        if (namespace.equals("java.package")) {
            return BundleInfo.PACKAGE_TYPE;
        }
        if (namespace.equals("osgi.bundle")) {
            return BundleInfo.BUNDLE_TYPE;
        }
        return null;
    }

    private class ProvidesHandler extends DelegatingHandler {

        private static final String PROVIDES = "provides";

        private static final String SIZE = "size";

        List<BundleCapability> capabilities;

        String eclipseType;

        public ProvidesHandler() {
            super(PROVIDES);
            addChild(new ProvidedHandler(), new ChildElementHandler<ProvidedHandler>() {
                @Override
                public void childHandled(ProvidedHandler child) {
                    if (child.namespace.equals("org.eclipse.equinox.p2.eclipse.type")) {
                        eclipseType = child.name;
                    } else {
                        String type = namespace2Type(child.namespace);
                        if (type == null) {
                            if (logLevel >= Message.MSG_DEBUG) {
                                Message.debug("Unsupported provided capability " + child.namespace
                                        + " " + child.name + " " + child.version);
                            }
                            return;
                        }
                        BundleCapability capability;
                        if (BundleInfo.PACKAGE_TYPE.equals(type)) {
                            capability = new ExportPackage(child.name, child.version);
                        } else {
                            capability = new BundleCapability(type, child.name, child.version);
                        }
                        capabilities.add(capability);
                    }
                }
            });
        }

        @Override
        protected void handleAttributes(Attributes atts) {
            int size = Integer.parseInt(atts.getValue(SIZE));
            capabilities = new ArrayList<>(size);
        }

    }

    private static class ProvidedHandler extends DelegatingHandler {

        private static final String PROVIDED = "provided";

        private static final String NAMESPACE = "namespace";

        private static final String NAME = "name";

        private static final String VERSION = "version";

        String namespace;

        String name;

        Version version;

        public ProvidedHandler() {
            super(PROVIDED);
        }

        @Override
        protected void handleAttributes(Attributes atts) throws SAXException {
            namespace = atts.getValue(NAMESPACE);
            name = atts.getValue(NAME);
            version = new Version(atts.getValue(VERSION));
        }

    }

    abstract class AbstractRequirementHandler extends DelegatingHandler {

        private static final String SIZE = "size";

        List<BundleRequirement> requirements;

        public AbstractRequirementHandler(String name) {
            super(name);
            addChild(new RequiredHandler(), new ChildElementHandler<RequiredHandler>() {
                @Override
                public void childHandled(RequiredHandler child) {
                    String name = child.name;
                    VersionRange range = child.range;
                    String type = namespace2Type(child.namespace);
                    if (type == null) {
                        if (logLevel >= Message.MSG_DEBUG) {
                            Message.debug("Unsupported required capability " + child.namespace
                                    + " " + name + " " + range);
                        }
                    } else {
                        String resolution = child.optional ? "optional" : null;
                        requirements.add(new BundleRequirement(type, name, range, resolution));
                    }
                }
            });
        }

        @Override
        protected void handleAttributes(Attributes atts) {
            int size = Integer.parseInt(atts.getValue(SIZE));
            requirements = new ArrayList<>(size);
        }

    }

    private class RequiresHandler extends AbstractRequirementHandler {

        private static final String REQUIRES = "requires";

        public RequiresHandler() {
            super(REQUIRES);
        }

    }

    private class RequiredHandler extends DelegatingHandler {

        private static final String REQUIRED = "required";

        private static final String NAMESPACE = "namespace";

        private static final String NAME = "name";

        private static final String RANGE = "range";

        private static final String OPTIONAL = "optional";

        // private static final String GREEDY = "greedy";

        String namespace;

        String name;

        VersionRange range;

        // String filter;
        //
        // boolean greedy;

        boolean optional;

        public RequiredHandler() {
            super(REQUIRED);
            // addChild(new FilterHandler(), new ChildElementHandler<FilterHandler>() {
            // public void childHandled(FilterHandler child) {
            // filter = child.getBufferedChars().trim();
            // }
            // });
        }

        @Override
        protected void handleAttributes(Attributes atts) throws SAXParseException {
            namespace = atts.getValue(NAMESPACE);
            name = atts.getValue(NAME);
            try {
                range = new VersionRange(atts.getValue(RANGE));
            } catch (ParseException e) {
                throw new RuntimeException(e);
            }
            // greedy = getOptionalBooleanAttribute(atts, GREEDY, Boolean.TRUE).booleanValue();
            optional = getOptionalBooleanAttribute(atts, OPTIONAL, Boolean.FALSE);
        }

    }

    private class HostRequirementsHandler extends AbstractRequirementHandler {

        private static final String HOST_REQUIREMENTS = "hostRequirements";

        public HostRequirementsHandler() {
            super(HOST_REQUIREMENTS);
        }

    }

    private class MetaRequirementsHandler extends AbstractRequirementHandler {

        private static final String META_REQUIREMENTS = "metaRequirements";

        public MetaRequirementsHandler() {
            super(META_REQUIREMENTS);
        }

    }

    private class ArtifactsHandler extends DelegatingHandler {

        private static final String ARTIFACTS = "artifacts";

        private static final String SIZE = "size";

        List<P2Artifact> artifacts;

        public ArtifactsHandler() {
            super(ARTIFACTS);
            addChild(new ArtifactHandler(), new ChildElementHandler<ArtifactHandler>() {
                @Override
                public void childHandled(ArtifactHandler child) {
                    artifacts.add(child.artifact);
                }
            });
        }

        @Override
        protected void handleAttributes(Attributes atts) {
            int size = Integer.parseInt(atts.getValue(SIZE));
            artifacts = new ArrayList<>(size);
        }

    }

    private class ArtifactHandler extends DelegatingHandler {

        private static final String ARTIFACT = "artifact";

        private static final String ID = "id";

        private static final String VERSION = "version";

        private static final String CLASSIFIER = "classifier";

        P2Artifact artifact;

        public ArtifactHandler() {
            super(ARTIFACT);
        }

        @Override
        protected void handleAttributes(Attributes atts) throws SAXException {
            String id = atts.getValue(ID);
            String version = atts.getValue(VERSION);
            String classifier = atts.getValue(CLASSIFIER);
            artifact = new P2Artifact(id, new Version(version), classifier);
        }

    }

    // private static class TouchpointHandler extends DelegatingHandler {
    //
    // private static final String TOUCHPOINT = "touchpoint";
    //
    // private static final String ID = "id";
    //
    // private static final String VERSION = "version";
    //
    // public TouchpointHandler() {
    // super(TOUCHPOINT);
    // }
    //
    // protected void handleAttributes(Attributes atts) {
    // String id = atts.getValue(ID);
    // String version = atts.getValue(VERSION);
    // }
    //
    // }

    private class TouchpointDataHandler extends DelegatingHandler {

        private static final String TOUCHPOINTDATA = "touchpointData";

        // private static final String SIZE = "size";

        String manifest;

        Boolean zipped;

        public TouchpointDataHandler() {
            super(TOUCHPOINTDATA);
            addChild(new InstructionsHandler(), new ChildElementHandler<InstructionsHandler>() {
                @Override
                public void childHandled(InstructionsHandler child) {
                    manifest = child.manifest;
                    zipped = child.zipped;
                }
            });
        }

        @Override
        protected void handleAttributes(Attributes atts) {
            // String size = atts.getValue(SIZE);
        }

    }

    private class InstructionsHandler extends DelegatingHandler {

        private static final String INSTRUCTIONS = "instructions";

        // private static final String SIZE = "size";

        String manifest;

        Boolean zipped;

        public InstructionsHandler() {
            super(INSTRUCTIONS);
            addChild(new InstructionHandler(), new ChildElementHandler<InstructionHandler>() {
                @Override
                public void childHandled(InstructionHandler child) {
                    manifest = null;
                    zipped = null;
                    String buffer = child.getBufferedChars().trim();
                    if ("manifest".equals(child.key)) {
                        manifest = buffer;
                    } else if ("zipped".equals(child.key) && buffer.length() != 0) {
                        zipped = Boolean.valueOf(buffer);
                    }
                }
            });
        }

        @Override
        protected void handleAttributes(Attributes atts) {
            // String size = atts.getValue(SIZE);
        }

    }

    private class InstructionHandler extends DelegatingHandler {

        private static final String INSTRUCTION = "instruction";

        private static final String KEY = "key";

        String key;

        public InstructionHandler() {
            super(INSTRUCTION);
            setBufferingChar(true);
        }

        @Override
        protected void handleAttributes(Attributes atts) {
            key = atts.getValue(KEY);
        }

    }

    // private static class LicensesHandler extends DelegatingHandler {
    //
    // private static final String LICENSES = "licenses";
    //
    // private static final String SIZE = "size";
    //
    // public LicensesHandler() {
    // super(LICENSES);
    // addChild(new LicenseHandler(), new ChildElementHandler() {
    // public void childHandled(DelegatingHandler child) {
    // }
    // });
    // }
    //
    // protected void handleAttributes(Attributes atts) {
    // String size = atts.getValue(SIZE);
    // }
    //
    // }

    // private static class LicenseHandler extends DelegatingHandler {
    //
    // private static final String LICENSE = "license";
    //
    // private static final String URI = "uri";
    //
    // private static final String URL = "url";
    //
    // public LicenseHandler() {
    // super(LICENSE);
    // setBufferingChar(true);
    // }
    //
    // protected void handleAttributes(Attributes atts) {
    // String uri = atts.getValue(URI);
    // String url = atts.getValue(URL);
    // }
    //
    // }

    // private static class CopyrightHandler extends DelegatingHandler {
    //
    // private static final String COPYRIGHT = "copyright";
    //
    // private static final String URI = "uri";
    //
    // private static final String URL = "url";
    //
    // public CopyrightHandler() {
    // super(COPYRIGHT);
    // }
    //
    // protected void handleAttributes(Attributes atts) {
    // String uri = atts.getValue(URI);
    // String url = atts.getValue(URL);
    // }
    //
    // }

    // private class ChangesHandler extends DelegatingHandler {
    //
    // private static final String CHANGES = "changes";
    //
    // private static final String SIZE = "size";
    //
    // public ChangesHandler() {
    // super(CHANGES);
    // addChild(new ChangeHandler(), new ChildElementHandler<ChangeHandler>() {
    // public void childHandled(ChangeHandler child) {
    // }
    // });
    // }
    //
    // protected void handleAttributes(Attributes atts) {
    // int size = Integer.parseInt(atts.getValue(SIZE));
    // }
    // }

    // private class ChangeHandler extends DelegatingHandler {
    //
    // private static final String CHANGE = "change";
    //
    // public ChangeHandler() {
    // super(CHANGE);
    // }
    // }

    // private class FromHandler extends AbstractRequirementHandler {
    //
    // private static final String FROM = "from";
    //
    // public FromHandler() {
    // super(FROM);
    // }
    //
    // }

    // private class ToHandler extends AbstractRequirementHandler {
    //
    // private static final String TO = "to";
    //
    // public ToHandler() {
    // super(TO);
    // }
    //
    // }

    // private class PatchScopeHandler extends DelegatingHandler {
    //
    // private static final String PATCH_SCOPE = "patchScope";
    //
    // private static final String SIZE = "size";
    //
    // public PatchScopeHandler() {
    // super(PATCH_SCOPE);
    // addChild(new PatchScopeHandler(), new ChildElementHandler<PatchScopeHandler>() {
    // public void childHandled(PatchScopeHandler child) {
    // }
    // });
    // }
    //
    // protected void handleAttributes(Attributes atts) {
    // int size = Integer.parseInt(atts.getValue(SIZE));
    // }
    // }

    // private class ScopeHandler extends DelegatingHandler {
    //
    // private static final String SCOPE = "scope";
    //
    // public ScopeHandler() {
    // super(SCOPE);
    // addChild(new RequiresHandler(), new ChildElementHandler<RequiresHandler>() {
    // public void childHandled(RequiresHandler child) {
    // }
    // });
    // }
    // }

    // private class LifeCycleHandler extends AbstractRequirementHandler {
    //
    // private static final String LIFE_CYCLE = "lifeCycle";
    //
    // public LifeCycleHandler() {
    // super(LIFE_CYCLE);
    // }
    // }

}
