/*******************************************************************************
 * Copyright (c) 23.04.2012 Aaron Digulla.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    Aaron Digulla - initial API and implementation and/or initial documentation
 *******************************************************************************/

package m4e.p2

import groovy.util.Node;

import java.io.File;
import java.util.List;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

class ContentXmlParser {
    static final Logger log = LoggerFactory.getLogger( ContentXmlParser )

    P2Repo repo
    ProviderResolver providerResolver
    VersionCache versionCache
    DependencyCache dependencyCache = new DependencyCache()
    
    void parseXml( File contentXmlFile ) {
        providerResolver = new ProviderResolver( repo: repo, dependencyCache: dependencyCache )
        versionCache = repo.versionCache
        
        def doc = new XmlParser().parse( contentXmlFile )
        parse( doc )
        
        log.debug( "Parsed ${contentXmlFile}" )
        log.debug( "dependencyCache has ${dependencyCache.cache.size()} elements" )
    }
    
    void parse( Node doc ) {
        
        String type = doc.'@type'
        if( type == 'org.eclipse.equinox.internal.p2.metadata.repository.CompositeMetadataRepository' ) {
            throw new CompositeRepoException()
        }
        
        if( type != 'org.eclipse.equinox.internal.p2.metadata.repository.LocalMetadataRepository' ) {
            throw new P2Exception( "Unsupported repository type ${type}" )
        }
        
        def units = doc.units
        
        log.info( "Found ${units.unit.size()} items." )
        
        for( Node unit : units.unit ) {
            
            def isCategory = getProperty( unit, 'org.eclipse.equinox.p2.type.category' )
            if( 'true' == isCategory ) {
                repo.categories << parseCategory( unit )
                continue
            }

            def artifacts = unit.artifacts[0]
            parsePluginOrFeature( unit, artifacts )
        }
        
        providerResolver.resolveRequirements()
        
        repo.categories.sort()
        repo.features.sort()
        repo.plugins.sort()
        repo.others.sort { "${it.id} ${it.version}" }
    }
    
    P2Category parseCategory( Node unit ) {
        def id = unit.'@id'
        def version = versionCache.version( unit.'@version' )
        def name = getProperty( unit, 'org.eclipse.equinox.p2.name' )
        def description = getDescription( unit )
        
        def category = new P2Category( id: id, version: version, name: name, description: description )
        category.dependencies = parseDependencies( unit )
        
        return category
    }
    
    List<P2Dependency> parseDependencies( Node unit ) {
        List<P2Dependency> result = []
        
        //println "parseDependencies ${unit.'@id'} ${unit.requires.size()} ${unit.artifacts.size()}"
        if( unit.requires ) {
            for( Node required : unit.requires[0].required ) {
                
                def type = required.'@namespace'
                def id = required.'@name'
                def versionRange = versionCache.range( required.'@range' )
                
                if( id.endsWith( '.feature.jar' ) ) {
                    continue
                }
                
                result << dependencyCache.dependency( id, type, versionRange )
            }
        }

        if( unit.artifacts ) {
            for( Node artifact: unit.artifacts[0].artifact ) {
                
                def type = artifact.'@classifier'
                def id = artifact.'@id'
                def versionRange = versionCache.range( artifact.'@version' )
                
                result << dependencyCache.dependency( id, type, versionRange )
            }
        }
        
        return result
    }
    
    String getProperty( Node unit, String name ) {
        def properties = unit.properties
        if( !properties || properties.size() == 0 ) {
            return null
        }
        
        properties = properties[0]
        return properties.property.find { name == it.'@name' }?.'@value'
    }
    
    void parsePluginOrFeature( Node unit, Node artifacts ) {

        String id = unit.'@id'
        //def updateFeaturePlugin = getProperty( unit, 'org.eclipse.update.feature.plugin' )
        if( id.endsWith( '.feature.jar' ) ) {
            // Ignore feature JARs
            return
        }
        
        String classifier = ''
        if( artifacts ) {
            classifier = artifacts.artifact[0].'@classifier'
        }

        def isTypeGroup = getProperty( unit, 'org.eclipse.equinox.p2.type.group' )
        //println "${unit.'@id'} ${classifier} ${isTypeGroup}"
        if( 'org.eclipse.update.feature' == classifier || 'true' == isTypeGroup || 'false' == isTypeGroup ) {
            parseFeature( unit )
            return
        }
        
        def typeFragment = getProperty( unit, 'org.eclipse.equinox.p2.type.fragment' )
        if( 'osgi.bundle' == classifier || 'binary' == classifier || 'true' == typeFragment ) {
            parsePlugin( unit )
            return
        }
        
        if( !artifacts ) {
            
            def requires = unit.requires
            if( id.startsWith( 'tooling' ) || id.startsWith( 'epp.package.' ) || !requires ) {
                repo.units << parseUnit( unit )
                return
            }
            
//            println "${id} ${requires}"
        }
        
        String xml = xmlToString( unit )
        repo.others << new P2Other( id: id, version: versionCache.version( unit.'@version' ), message: "Unable to determine type", xml: xml )
    }
    
    P2Unit parseUnit( Node unit ) {
        String xml = xmlToString( unit )
        String id = unit.'@id'
        
        def result = new P2Unit( id: id, version: versionCache.version( unit.'@version' ), xml: xml )
        return result
    }
    
    String xmlToString( Node node ) {
        StringWriter buffer = new StringWriter( 10240 )
        def ip = new IndentPrinter( buffer, '    ' )
        def printer = new XmlNodePrinter( ip )
        printer.print( node )
        String xml = buffer.toString()
        return xml
    }
    
    P2Feature parseFeature( Node unit ) {
        def id = unit.'@id'
        def version = versionCache.version( unit.'@version' )
        def name = getName( unit )
        def description = getDescription( unit )
        if( name == description ) {
            description = null
        }

        def result = new P2Feature( id: id, version: version, name: name, description: description )
        result.dependencies = parseDependencies( unit )
        
        repo.features << result
        providerResolver.register( result, unit )
        repo.bundlesById.get( id ) << result

        return result
    }
    
    String getName( Node unit ) {
        
        String name = getProperty( unit, 'org.eclipse.equinox.p2.name' )
        if( name && name.startsWith( '%' ) ) {
            String key = 'df_LT.' + name.substring( 1 )
            name = getProperty( unit, key )
        }
        
        if( name ) {
            return name
        }
        
        return unit.'@id'
    }
    
    String getDescription( Node unit ) {
        def description = getProperty( unit, 'org.eclipse.equinox.p2.description' )
        if( !description ) {
            return null
        }
        
        if( description.startsWith( '%' ) ) {
            String key = 'df_LT.' + description.substring( 1 )
            description = getProperty( unit, key )
        }
        
        return description
    }
    
    P2Plugin parsePlugin( Node unit ) {
        def id = unit.'@id'
        def version = versionCache.version( unit.'@version' )
        def name = getName( unit )
        def description = getDescription( unit )
        if( name == description ) {
            description = null
        }
        boolean source = false
        if( unit.provides ) {
            for( Node provided : unit.provides[0].provided ) {
                String namespace = provided.'@namespace'
                if( 'org.eclipse.equinox.p2.eclipse.type' == namespace ) {
                    source = 'source' == provided.'@name'
                    break
                }
            }
        }
        
        def result = new P2Plugin( id: id, version: version, name: name, description: description, source: source )
        result.dependencies = parseDependencies( unit )
        
        repo.plugins << result
        providerResolver.register( result, unit )
        repo.bundlesById.get( id ) << result
        
        return result
    }
    
}