/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  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.  For additional information regarding
 * copyright in this work, please see the NOTICE file in the top level
 * directory of this distribution.
 */
package org.apache.abdera2.common.templates;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

import org.apache.abdera2.common.iri.IRI;


public class TemplateManager<T>
  implements Iterable<T> { 

  private final Map<T,Template> templates = 
    new HashMap<T,Template>();
  private final boolean isiri;
  private final IRI base;
  private final Context contextDefaults;

  public TemplateManager(String base) {
    this(new IRI(base));
  }
  
  public TemplateManager(IRI base) {
    this.isiri = true;
    this.base = base;
    this.contextDefaults = null;
  }
  
  public TemplateManager() {
    this.isiri = true;
    this.base = null;
    this.contextDefaults = null;
  }
  
  public TemplateManager(String base, boolean iri) {
    this(new IRI(base),iri);
  }
  
  public TemplateManager(IRI base, boolean iri) {
    this.isiri = iri;
    this.base = base;
    this.contextDefaults = null;
  }
  
  public TemplateManager(boolean iri) {
    this.isiri = iri;
    this.base = null;
    this.contextDefaults = null;
  }

  public TemplateManager(String base, Context defaults) {
    this(new IRI(base),defaults);
  }
  
  public TemplateManager(IRI base, Context defaults) {
    if (defaults == null)
      throw new IllegalArgumentException();
    this.isiri = defaults.isIri();
    this.contextDefaults = defaults;
    this.base = base;
  }
  
  public TemplateManager(Context defaults) {
    this((IRI)null,defaults);
  }
  
  public TemplateManager(String base, Object defaults) {
    this(new IRI(base),defaults);
  }
  
  public TemplateManager(IRI base, Object defaults) {
    this(base,defaults,true);
  }
 
  public TemplateManager(Object defaults) {
    this((IRI)null,defaults,true);
  }
  
  public TemplateManager(Object defaults, boolean isiri) {
    this(_innerContext(defaults,isiri));
  }
  
  public TemplateManager(String base, Object defaults, boolean isiri) {
    this(new IRI(base),defaults,isiri);
  }
  
  public TemplateManager(IRI base, Object defaults, boolean isiri) {
    this(base,_innerContext(defaults,isiri));
  }
  
  public Context getDefaultContext() {
    return this.contextDefaults;
  }
  
  public void add(T key, Template template) {
    this.templates.put(key,template);
  }
  
  public void add(T key, String template) {
    add(key, new Template(template));
  }
  
  public void add(T key, Object template) {
    add(key, new Template(template));
  }
  
  public void add(Map<T,Object> templates) {
    TemplateManager<T> tm = fromMap(templates);
    this.templates.putAll(tm.templates);
  }
  
  public String expandAndResolve(T key, Object object, String base) {
    IRI iri = expandAndResolve(key,object,new IRI(base));
    return iri != null ? iri.toString() : null;
  }
  
  public IRI expandAndResolve(T key, Object object, IRI base) {
    String ex = expand(key,object);
    return ex != null ? 
        base == null ? 
            new IRI(ex) : 
            base.resolve(ex) : 
        null;    
  }
  
  public IRI expandAndResolve(T key, Object object) {
    return expandAndResolve(key,object,base);
  }
 
  public String expandAndResolve(T key, Context context, String base) {
    IRI iri = expandAndResolve(key,context,new IRI(base));
    return iri != null ? iri.normalize().toString() : null;
  }
  
  public IRI expandAndResolve(T key, Context context, IRI base) {
    String ex = expand(key,context);
    return ex != null ? 
        base == null ? 
            new IRI(ex) : 
            base.resolve(ex) : 
        null;    
  }
  
  public IRI expandAndResolve(T key, Context context) {
    return expandAndResolve(key,context,base);    
  }
  
  public String expand(T key, Object object) {
    if (!templates.containsKey(key))
      return null;
    Template template = templates.get(key);
    return template.expand(_wrap(_innerContext(object,isiri),contextDefaults));
  }
  
  public String expand(T key) {
    if (contextDefaults == null)
      throw new IllegalArgumentException();
    return expand(key,contextDefaults);
  }
  
  public String expand(T key, Context context) {
    if (!templates.containsKey(key))
      return null;
    Template template = templates.get(key);
    return template.expand(_wrap(context,contextDefaults));
  }
  
  @SuppressWarnings("unchecked")
  private static Context _innerContext(Object object, boolean isiri) {
    return object instanceof Context ? (Context)object : object instanceof Map
        ? new MapContext((Map<String,Object>)object, isiri) : new ObjectContext(object, isiri);
  }
  
  private static Context _wrap(Context context, Context contextDefaults) {
    return contextDefaults != null ? 
      new DefaultingContext(context,contextDefaults) : context;
  }

  public Iterator<T> iterator() {
    return templates.keySet().iterator();
  }

  @Override
  public int hashCode() {
    final int prime = 31;
    int result = 1;
    result = prime * result
        + ((contextDefaults == null) ? 0 : contextDefaults.hashCode());
    result = prime * result + (isiri ? 1231 : 1237);
    result = prime * result + ((templates == null) ? 0 : templates.hashCode());
    return result;
  }

  @Override
  @SuppressWarnings("rawtypes")
  public boolean equals(Object obj) {
    if (this == obj)
      return true;
    if (obj == null)
      return false;
    if (getClass() != obj.getClass())
      return false;
    TemplateManager other = (TemplateManager) obj;
    if (contextDefaults == null) {
      if (other.contextDefaults != null)
        return false;
    } else if (!contextDefaults.equals(other.contextDefaults))
      return false;
    if (isiri != other.isiri)
      return false;
    if (templates == null) {
      if (other.templates != null)
        return false;
    } else if (!templates.equals(other.templates))
      return false;
    return true;
  }
 
  public static <T>TemplateManager<T> fromMap(Map<T,Object> map) {
    TemplateManager<T> tm = new TemplateManager<T>();
    for (Map.Entry<T, Object> entry : map.entrySet()) {
      tm.add(entry.getKey(),entry.getValue());
    }
    return tm;
  }
}