/**
  *
  *                      OOAS Compiler
  *
  *       Copyright 2015, AIT Austrian Institute of Technology.
  * This code is based on the C# Version of the OOAS Compiler, which is
  * copyright 2015 by the Institute of Software Technology, Graz University
  * of Technology with portions copyright by the AIT Austrian Institute of
  * Technology. All rights reserved.
  *
  * SEE THE "LICENSE" FILE FOR THE TERMS UNDER WHICH THIS FILE IS PROVIDED.
  *
  * If you modify the file please update the list of contributors below to in-
  * clude your name. Please also stick to the coding convention of using TABs
  * to do the basic (block-level) indentation and spaces for anything after
  * that. (Enable the display of special chars and it should be pretty obvious
  * what this means.) Also, remove all trailing whitespace.
  *
  * Contributors:
  *               Willibald Krenn (AIT)
  *               Stephan Zimmerer (AIT)
  *               Markus Demetz (AIT)
  *               Christoph Czurda (AIT)
  *
  */


package org.momut.ooas.visitors;

import java.util.ArrayList;
import java.util.EnumMap;
import java.util.List;
import java.util.Set;
import java.util.TreeMap;

import org.momut.ooas.CompilerConfiguration.LabelCompression;
import org.momut.ooas.ast.identifiers.AttributeIdentifier;
import org.momut.ooas.ast.identifiers.Identifier;
import org.momut.ooas.ast.identifiers.IdentifierKind;
import org.momut.ooas.ast.identifiers.MethodIdentifier;
import org.momut.ooas.ast.identifiers.NamedActionIdentifier;
import org.momut.ooas.ast.types.FunctionType;
import org.momut.ooas.ast.types.OoActionSystemInstance;
import org.momut.ooas.ast.types.FunctionType.FunctionTypeEnum;
import org.momut.ooas.parser.ParserState;
import org.momut.ooas.utils.exceptions.ArgumentException;
import org.momut.ooas.utils.exceptions.NotImplementedException;

public class OoaIdentifierCompressVisitor extends OoaCompleteAstTraversalVisitor {

	public static final String s_methodPrefix    = "m_";
	public static final String s_actionPrefix    = "a_";
	public static final String s_attributePrefix = "at_";
	public static final String s_objectPrefix    = "o_";
	public static final String s_typePrefix      = "t_";

	private final EnumMap<IdentifierKind, TreeMap<String, String> > m_identifierMappings = new EnumMap<>(IdentifierKind.class);
	private final TreeMap<String, String> m_objectMappings = new TreeMap<>();
	private final LabelCompression m_compression;

	private void putMapping(String label, Identifier identifier) {
		TreeMap<String, String> map = m_identifierMappings.get(identifier.kind());
		if (map == null) {
			map = new TreeMap<>();
			m_identifierMappings.put(identifier.kind(), map);
		}
		map.put(label, identifier.tokenText());
	}

	public String mappingFor(Identifier identifier)	{
		final IdentifierKind kind = identifier.kind();
		final TreeMap<String, String> map = m_identifierMappings.get(kind);
		return map.get(identifier.tokenText());
	}

	@Override
	public /*override*/ void visit(AttributeIdentifier attributeIdentifier)	{
		if (m_compression != LabelCompression.All)
			return;
		final String attributeName = labelFor(attributeIdentifier);
		attributeIdentifier.SetTokenText(attributeName);
	}

	@Override
	public /*override*/ void visit(MethodIdentifier methodIdentifier)	{
		final String renamedName = labelFor(methodIdentifier);
		methodIdentifier.SetTokenText(renamedName);
	}

	@Override
	public /*override*/ void visit(NamedActionIdentifier namedActionIdentifier)	{
		final FunctionType functionType = (FunctionType) namedActionIdentifier.type();
		if (functionType.functionType() == FunctionTypeEnum.Internal) {
				final String renamedName = labelFor(namedActionIdentifier);
				namedActionIdentifier.SetTokenText(renamedName);
		}
	}

	public String labelFor(Identifier identifier) {
		String label = identifier.tokenText();

		switch(identifier.kind()) {
			case MethodIdentifier:
				label = s_methodPrefix + convert(methodCount++);
				break;
			case NamedActionIdentifier:
				label = s_actionPrefix + convert(actionCount++);
				break;
			case AttributeIdentifier:
				label = s_attributePrefix + convert(attributeCount++);
				break;
			default:
				throw new NotImplementedException();
		}
		putMapping(label, identifier);
		return label;
	}

	public String labelFor(OoActionSystemInstance instance) {
		final String label = s_objectPrefix + convert(objectCount++);
		m_objectMappings.put(label, instance.Name);
		return label;
	}

	public String originalName(String key) {
		if(m_objectMappings.get(key) != null) {
			return m_objectMappings.get(key);
		}
		return key;
	}

	public List<String> mappingInformation() {
		final List<String> lines = new ArrayList<>();
		final Set<IdentifierKind> kinds = m_identifierMappings.keySet();

		for (final IdentifierKind kind: kinds) {
			final TreeMap<String, String> map = m_identifierMappings.get(kind);
			final Set<String> keys = map.keySet();
			lines.add(String.format("[ Mappings for '%s' ]", kind.name()));
			for(final String key: keys) {
				lines.add(String.format("'%s' => '%s'", key, map.get(key)));
			}
			lines.add("");
		}

		if (m_objectMappings.isEmpty())
			return lines;

		lines.add(String.format("[ Object mappings ]"));
		final Set<String> keys = m_objectMappings.keySet();
		for (final String key: keys) {
			lines.add(String.format("'%s' => '%s'", key, originalName(key)));
		}
		lines.add("");
		return lines;
	}

	public LabelCompression compression() {
		return m_compression;
	}

	static final String CHARS = "abcdefghijklmnopqrstuvwxyz"; /* ABCDEFGHIJKLMNOPQRSTUVWXYZ */
	static final int CHARS_LENGTH = CHARS.length();

	int actionCount = 0;
	int methodCount = 0;
	int attributeCount = 0;
	int objectCount = 0;

	private String convert(int id) {
		final StringBuilder sb = new StringBuilder();
		do {
			sb.append(CHARS.charAt(id % CHARS_LENGTH));
			id = id / CHARS_LENGTH;
		} while(id != 0);
		return sb.toString();
	}

	public OoaIdentifierCompressVisitor(ParserState aState, LabelCompression compression)
	{
		super (aState);
		if (aState == null || compression == null)
			throw new ArgumentException();
		m_compression = compression;
	}
}