/*
 * JBoss, Home of Professional Open Source
 * Copyright 2005, JBoss Inc., and individual contributors as indicated
 * by the @authors tag. See the copyright.txt in the distribution for a
 * full listing of individual contributors.
 *
 * This is free software; you can redistribute it and/or modify it
 * under the terms of the GNU Lesser General Public License as
 * published by the Free Software Foundation; either version 2.1 of
 * the License, or (at your option) any later version.
 *
 * This software is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this software; if not, write to the Free
 * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
 * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
 */
package org.jbpm.pvm.internal.wire.binding;

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

import org.jbpm.pvm.internal.stream.FileStreamInput;
import org.jbpm.pvm.internal.stream.ResourceStreamInput;
import org.jbpm.pvm.internal.stream.StreamInput;
import org.jbpm.pvm.internal.stream.UrlStreamInput;
import org.jbpm.pvm.internal.type.Converter;
import org.jbpm.pvm.internal.type.Matcher;
import org.jbpm.pvm.internal.type.Type;
import org.jbpm.pvm.internal.type.TypeMapping;
import org.jbpm.pvm.internal.type.matcher.ClassNameMatcher;
import org.jbpm.pvm.internal.type.matcher.HibernateLongIdMatcher;
import org.jbpm.pvm.internal.type.matcher.HibernateStringIdMatcher;
import org.jbpm.pvm.internal.type.matcher.SerializableMatcher;
import org.jbpm.pvm.internal.util.XmlUtil;
import org.jbpm.pvm.internal.wire.Descriptor;
import org.jbpm.pvm.internal.wire.WireContext;
import org.jbpm.pvm.internal.wire.descriptor.TypesDescriptor;
import org.jbpm.pvm.internal.xml.Parse;
import org.jbpm.pvm.internal.xml.Parser;
import org.w3c.dom.Element;

/** parses a descriptor for Boolean.TRUE.
 * 
 * See schema docs for more details.
 *
 * @author Tom Baeyens
 */
public class TypesBinding extends WireDescriptorBinding {
  
  public TypesBinding() {
    super("types");
  }

  public Object parse(Element element, Parse parse, Parser parser) {
    StreamInput streamSource = null;
    if (element.hasAttribute("file")) {
      String fileName = element.getAttribute("file");
      File file = new File(fileName);
      if (file.exists() && file.isFile()) {
        streamSource = new FileStreamInput(file);
        parser.importStream(streamSource, element, parse);
      } else {
        parse.addProblem("file "+fileName+" isn't a file", element);
      }
    }
    
    if (element.hasAttribute("resource")) {
      String resource = element.getAttribute("resource");
      ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
      streamSource = new ResourceStreamInput(resource, classLoader);
      parser.importStream(streamSource, element, parse);
    }
    
    if (element.hasAttribute("url")) {
      String urlText = element.getAttribute("url");
      try {
        URL url = new URL(urlText);
        streamSource = new UrlStreamInput(url);
        parser.importStream(streamSource, element, parse);
      } catch (Exception e) {
        parse.addProblem("couldn't open url "+urlText, e);
      }
    }
    
    TypesDescriptor typesDescriptor = new TypesDescriptor();
    
    List<Element> typeElements = XmlUtil.elements(element, "type");
    for (Element typeElement: typeElements) {
      TypeMapping typeMapping = parseTypeMapping(typeElement, parse, parser);
      typesDescriptor.addTypeMapping(typeMapping);
    }
    return typesDescriptor;
  }

  protected TypeMapping parseTypeMapping(Element element, Parse parse, Parser parser) {
    TypeMapping typeMapping = new TypeMapping();
    Type type = new Type();
    typeMapping.setType(type);
    
    // type name
    if (element.hasAttribute("name")) {
      type.setName(element.getAttribute("name"));
    }
    
    String hibernateSessionFactoryName = XmlUtil.attribute(element, "hibernate-session-factory");
    
    // first we get the matcher
    Matcher matcher = null;
    if (element.hasAttribute("class")) {
      String className = element.getAttribute("class");
      
      // if type="serializable"
      if ("serializable".equals(className)) {
        matcher = new SerializableMatcher();
        
      // if type="hibernatable"
      } else if ("hibernatable".equals(className)) {
        if (element.hasAttribute("id-type")) {
          String idType = element.getAttribute("id-type");
          if ("long".equalsIgnoreCase(idType)) {
            matcher = new HibernateLongIdMatcher(hibernateSessionFactoryName); 
          } else if ("string".equalsIgnoreCase(idType)) {
            matcher = new HibernateStringIdMatcher(hibernateSessionFactoryName); 
          } else {
            parse.addProblem("id-type was not 'long' or 'string': "+idType, element);
          }
        } else {
          parse.addProblem("id-type is required in a persistable type", element);
        }

      // otherwise, we expect type="some.java.ClassName"
      } else {
        matcher = new ClassNameMatcher(className);
      }

    } else {
      // look for the matcher element
      Element matcherElement = XmlUtil.element(element, "matcher");
      Element matcherObjectElement = XmlUtil.element(matcherElement);
      if (matcherObjectElement!=null) {
        try {
          Descriptor descriptor = (Descriptor) parser.parseElement(matcherObjectElement, parse);
          matcher = (Matcher) WireContext.create(descriptor);
        } catch (ClassCastException e) {
          parse.addProblem("matcher is not a "+Matcher.class.getName()+": "+(matcher!=null ? matcher.getClass().getName() : "null"), element);
        }
      } else {
        parse.addProblem("no matcher specified in "+XmlUtil.toString(element), element);
      }
    }

    typeMapping.setMatcher(matcher);

    // parsing the converter 
    Converter converter = null;
    if (element.hasAttribute("converter")) {
      String converterClassName = element.getAttribute("converter");
      try {
        ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
        Class<?> converterClass = Class.forName(converterClassName, true, classLoader);
        converter = (Converter) converterClass.newInstance();
      } catch (Exception e) {
        parse.addProblem("couldn't instantiate converter "+converterClassName, element);
      }
    } else {
      // look for the matcher element
      Element converterElement = XmlUtil.element(element, "converter");
      Element converterObjectElement = XmlUtil.element(converterElement);
      if (converterObjectElement!=null) {
        try {
          converter = (Converter) parser.parseElement(converterObjectElement, parse);
        } catch (ClassCastException e) {
          parse.addProblem("converter is not a "+Converter.class.getName()+": "+(converter!=null ? converter.getClass().getName() : "null"), element);
        }
      } 
    }

    type.setConverter(converter);
    
    // parsing the variable class
    
    Class<?> variableClass = null;
    if (element.hasAttribute("variable-class")) {
      String variableClassName = element.getAttribute("variable-class"); 
      try {
        ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
        variableClass = Class.forName(variableClassName, true, classLoader);
      } catch (Exception e) {
        parse.addProblem("couldn't instantiate variable-class "+variableClassName, e);
      }
    } else {
      parse.addProblem("variable-class is required on a type: "+XmlUtil.toString(element), element);
    }

    type.setVariableClass(variableClass);
    
    return typeMapping;
  }
}