/*******************************************************************************
 * Copyright (c) 2015 Jeff Martin.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the GNU Lesser General Public
 * License v3.0 which accompanies this distribution, and is available at
 * http://www.gnu.org/licenses/lgpl.html
 * <p>
 * Contributors:
 * Jeff Martin - initial API and implementation
 ******************************************************************************/
package cuchaz.enigma.analysis;

import com.google.common.collect.Lists;
import com.google.common.collect.Multimap;
import com.google.common.collect.Sets;

import java.util.AbstractMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

import cuchaz.enigma.mapping.*;

public class EntryRenamer {

    public static <T> void renameClassesInSet(Map<String, String> renames, Set<T> set) {
        List<T> entries = Lists.newArrayList();
        for (T val : set) {
            entries.add(renameClassesInThing(renames, val));
        }
        set.clear();
        set.addAll(entries);
    }

    public static <Key, Val> void renameClassesInMap(Map<String, String> renames, Map<Key, Val> map) {
        // for each key/value pair...
        Set<Map.Entry<Key, Val>> entriesToAdd = Sets.newHashSet();
        for (Map.Entry<Key, Val> entry : map.entrySet()) {
            entriesToAdd.add(new AbstractMap.SimpleEntry<Key, Val>(
                    renameClassesInThing(renames, entry.getKey()),
                    renameClassesInThing(renames, entry.getValue())
            ));
        }
        map.clear();
        for (Map.Entry<Key, Val> entry : entriesToAdd) {
            map.put(entry.getKey(), entry.getValue());
        }
    }

    public static <Key, Val> void renameClassesInMultimap(Map<String, String> renames, Multimap<Key, Val> map) {
        // for each key/value pair...
        Set<Map.Entry<Key, Val>> entriesToAdd = Sets.newHashSet();
        for (Map.Entry<Key, Val> entry : map.entries()) {
            entriesToAdd.add(new AbstractMap.SimpleEntry<Key, Val>(
                    renameClassesInThing(renames, entry.getKey()),
                    renameClassesInThing(renames, entry.getValue())
            ));
        }
        map.clear();
        for (Map.Entry<Key, Val> entry : entriesToAdd) {
            map.put(entry.getKey(), entry.getValue());
        }
    }

    public static <Key, Val> void renameMethodsInMultimap(Map<MethodEntry, MethodEntry> renames, Multimap<Key, Val> map) {
        // for each key/value pair...
        Set<Map.Entry<Key, Val>> entriesToAdd = Sets.newHashSet();
        for (Map.Entry<Key, Val> entry : map.entries()) {
            entriesToAdd.add(new AbstractMap.SimpleEntry<Key, Val>(
                    renameMethodsInThing(renames, entry.getKey()),
                    renameMethodsInThing(renames, entry.getValue())
            ));
        }
        map.clear();
        for (Map.Entry<Key, Val> entry : entriesToAdd) {
            map.put(entry.getKey(), entry.getValue());
        }
    }

    public static <Key, Val> void renameMethodsInMap(Map<MethodEntry, MethodEntry> renames, Map<Key, Val> map) {
        // for each key/value pair...
        Set<Map.Entry<Key, Val>> entriesToAdd = Sets.newHashSet();
        for (Map.Entry<Key, Val> entry : map.entrySet()) {
            entriesToAdd.add(new AbstractMap.SimpleEntry<Key, Val>(
                    renameMethodsInThing(renames, entry.getKey()),
                    renameMethodsInThing(renames, entry.getValue())
            ));
        }
        map.clear();
        for (Map.Entry<Key, Val> entry : entriesToAdd) {
            map.put(entry.getKey(), entry.getValue());
        }
    }

    @SuppressWarnings("unchecked")
    public static <T> T renameMethodsInThing(Map<MethodEntry, MethodEntry> renames, T thing) {
        if (thing instanceof MethodEntry) {
            MethodEntry methodEntry = (MethodEntry) thing;
            MethodEntry newMethodEntry = renames.get(methodEntry);
            if (newMethodEntry != null) {
                return (T) new MethodEntry(
                        methodEntry.getClassEntry(),
                        newMethodEntry.getName(),
                        methodEntry.getSignature()
                );
            }
            return thing;
        } else if (thing instanceof ArgumentEntry) {
            ArgumentEntry argumentEntry = (ArgumentEntry) thing;
            return (T) new ArgumentEntry(
                    renameMethodsInThing(renames, argumentEntry.getBehaviorEntry()),
                    argumentEntry.getIndex(),
                    argumentEntry.getName()
            );
        } else if (thing instanceof EntryReference) {
            EntryReference<Entry, Entry> reference = (EntryReference<Entry, Entry>) thing;
            reference.entry = renameMethodsInThing(renames, reference.entry);
            reference.context = renameMethodsInThing(renames, reference.context);
            return thing;
        }
        return thing;
    }

    @SuppressWarnings("unchecked")
    public static <T> T renameClassesInThing(final Map<String, String> renames, T thing) {
        if (thing instanceof String) {
            String stringEntry = (String) thing;
            if (renames.containsKey(stringEntry)) {
                return (T) renames.get(stringEntry);
            }
        } else if (thing instanceof ClassEntry) {
            ClassEntry classEntry = (ClassEntry) thing;
            return (T) new ClassEntry(renameClassesInThing(renames, classEntry.getClassName()));
        } else if (thing instanceof FieldEntry) {
            FieldEntry fieldEntry = (FieldEntry) thing;
            return (T) new FieldEntry(
                    renameClassesInThing(renames, fieldEntry.getClassEntry()),
                    fieldEntry.getName(),
                    renameClassesInThing(renames, fieldEntry.getType())
            );
        } else if (thing instanceof ConstructorEntry) {
            ConstructorEntry constructorEntry = (ConstructorEntry) thing;
            return (T) new ConstructorEntry(
                    renameClassesInThing(renames, constructorEntry.getClassEntry()),
                    renameClassesInThing(renames, constructorEntry.getSignature())
            );
        } else if (thing instanceof MethodEntry) {
            MethodEntry methodEntry = (MethodEntry) thing;
            return (T) new MethodEntry(
                    renameClassesInThing(renames, methodEntry.getClassEntry()),
                    methodEntry.getName(),
                    renameClassesInThing(renames, methodEntry.getSignature())
            );
        } else if (thing instanceof ArgumentEntry) {
            ArgumentEntry argumentEntry = (ArgumentEntry) thing;
            return (T) new ArgumentEntry(
                    renameClassesInThing(renames, argumentEntry.getBehaviorEntry()),
                    argumentEntry.getIndex(),
                    argumentEntry.getName()
            );
        } else if (thing instanceof EntryReference) {
            EntryReference<Entry, Entry> reference = (EntryReference<Entry, Entry>) thing;
            reference.entry = renameClassesInThing(renames, reference.entry);
            reference.context = renameClassesInThing(renames, reference.context);
            return thing;
        } else if (thing instanceof Signature) {
            return (T) new Signature((Signature) thing, new ClassNameReplacer() {
                @Override
                public String replace(String className) {
                    return renameClassesInThing(renames, className);
                }
            });
        } else if (thing instanceof Type) {
            return (T) new Type((Type) thing, new ClassNameReplacer() {
                @Override
                public String replace(String className) {
                    return renameClassesInThing(renames, className);
                }
            });
        }

        return thing;
    }
}