/*-
    * #%L
    * io.earcam.instrumental.module.manifest
    * %%
    * Copyright (C) 2018 earcam
    * %%
    * SPDX-License-Identifier: (BSD-3-Clause OR EPL-1.0 OR Apache-2.0 OR MIT)
    * 
    * You <b>must</b> choose to accept, in full - any individual or combination of 
   * the following licenses:
   * <ul>
   * 	<li><a href="https://opensource.org/licenses/BSD-3-Clause">BSD-3-Clause</a></li>
   * 	<li><a href="https://www.eclipse.org/legal/epl-v10.html">EPL-1.0</a></li>
   * 	<li><a href="https://www.apache.org/licenses/LICENSE-2.0">Apache-2.0</a></li>
   * 	<li><a href="https://opensource.org/licenses/MIT">MIT</a></li>
   * </ul>
   * #L%
   */
  package io.earcam.instrumental.module.manifest;
  
  import java.io.OutputStream;
  import java.util.HashMap;
  import java.util.Map;
  import java.util.Objects;
  import java.util.Map.Entry;
  import java.util.jar.Attributes;
  import java.util.jar.Attributes.Name;
  import java.util.jar.Manifest;
  
  import javax.annotation.WillNotClose;
  
  import io.earcam.unexceptional.Exceptional;
  
  /**
   * <p>
   * Abstract AbstractManifestBuilder class.
   * </p>
   *
   */
  public abstract class AbstractManifestBuilder<T extends ManifestInfoBuilder<T>> implements ManifestInfo, ManifestInfoBuilder<T> {
  
  	protected final Map<Name, CharSequence> mainAttributes = new HashMap<>();
  	protected final Map<String, Map<Name, CharSequence>> namedEntries = new HashMap<>();
  
  	protected boolean hooked = false;
  
  
  	/**
  	 * <p>
  	 * self.
  	 * </p>
  	 *
  	 * @return a T object.
  	 */
  	protected abstract T self();
  
  
  	@Override
  	public boolean equals(Object other)
  	{
  		return other instanceof AbstractManifestBuilder && equals(AbstractManifestBuilder.class.cast(other));
  	}
  
  
  	/**
  	 * <p>
  	 * Implementers should use check own properties, invoke {@code instanceof} and then delegate to
  	 * {@link #same(AbstractManifestBuilder)}
  	 * </p>
  	 *
  	 * @param that an {@link AbstractManifestBuilder} instance.
  	 * @see #same(AbstractManifestBuilder)
  	 * @return a boolean.
  	 */
  	public abstract boolean equals(AbstractManifestBuilder<?> that);
  
  
  	/**
  	 * <p>
  	 * same.
  	 * </p>
  	 *
  	 * @param that a {@link AbstractManifestBuilder} object.
  	 * @return a boolean.
  	 */
  	protected final boolean same(AbstractManifestBuilder<?> that)
  	{
  		return that != null
  				&& Objects.equals(that.mainAttributes, mainAttributes)
  				&& Objects.equals(that.namedEntries, namedEntries);
  	}
  
  
  	@Override
  	public int hashCode()
  	{
  		return Objects.hash(mainAttributes, namedEntries);
  	}
  
 
 	@Override
 	public T manifestMain(Entry<Name, ? extends CharSequence> attribute)
 	{
 		mainAttributes.put(attribute.getKey(), attribute.getValue());
 		return self();
 	}
 
 
 	@Override
 	public T manifestNamed(ManifestNamedEntry entry)
 	{
 		Map<Name, CharSequence> attributes = namedEntries.computeIfAbsent(entry.name(), n -> new HashMap<>());
 		attributes.putAll(entry.attributes());
 		return self();
 	}
 
 
 	@Override
 	public T mergeFrom(Manifest manifest)
 	{
 		for(Object entry : manifest.getMainAttributes().entrySet()) {
 			@SuppressWarnings("unchecked")
 			Entry<Name, String> x = (Entry<Name, String>) entry;
 			manifestMain(x);
 		}
 
 		for(Map.Entry<String, Attributes> namedEntry : manifest.getEntries().entrySet()) {
 			ManifestNamedEntry x = ManifestNamedEntry.entry(namedEntry.getKey());
 			for(Entry<Object, Object> entry : namedEntry.getValue().entrySet()) {
 				x.attribute((Name) entry.getKey(), (String) entry.getValue());
 			}
 			manifestNamed(x);
 		}
 		return self();
 	}
 
 
 	@Override
 	public Manifest to(Manifest manifest)
 	{
 		hook();
 		mainAttributes.entrySet().forEach(e -> manifest.getMainAttributes().putIfAbsent(e.getKey(), e.getValue().toString()));
 
 		Map<String, Attributes> entries = manifest.getEntries();
 		for(Entry<String, Map<Name, CharSequence>> named : namedEntries.entrySet()) {
 
 			Attributes sink = entries.computeIfAbsent(named.getKey(), n -> new Attributes());
 			for(Entry<Name, CharSequence> source : named.getValue().entrySet()) {
 				sink.put(source.getKey(), source.getValue().toString());
 			}
 		}
 		return manifest;
 	}
 
 
 	/**
 	 * <p>
 	 * hook.
 	 * </p>
 	 */
 	protected final void hook()
 	{
 		if(!hooked) {
 			preBuildHook();
 			hooked = true;
 			preFlightChecks();
 		}
 	}
 
 
 	private void preFlightChecks()
 	{
 		if(!(mainAttributes.containsKey(Name.MANIFEST_VERSION) || mainAttributes.containsKey(Name.SIGNATURE_VERSION))) {
 			mainAttributes.put(Name.MANIFEST_VERSION, "1.0");
 		}
 	}
 
 
 	/**
 	 * <p>
 	 * preBuildHook.
 	 * </p>
 	 */
 	protected abstract void preBuildHook();
 
 
 	/**
 	 * <p>
 	 * unhook.
 	 * </p>
 	 */
 	protected final void unhook()
 	{
 		hooked = false;
 		// landingChecks
 	}
 
 
 	@Override
 	public void to(@WillNotClose OutputStream out)
 	{
 		hook();
 		Exceptional.accept(toManifest()::write, out);
 	}
 
 
 	/**
 	 * <p>
 	 * mainAttributes.
 	 * </p>
 	 *
 	 * @return a {@link java.util.Map} object.
 	 */
 	public Map<Name, CharSequence> mainAttributes()
 	{
 		return mainAttributes;
 	}
 
 
 	/**
 	 * <p>
 	 * namedEntries.
 	 * </p>
 	 *
 	 * @return a {@link java.util.Map} object.
 	 */
 	public Map<String, Map<Name, CharSequence>> namedEntries()
 	{
 		return namedEntries;
 	}
 }