source: trunk/src/org/expeditee/encryption/items/surrogates/Surrogate.java@ 1410

package org.expeditee.encryption.items.surrogates;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;

import org.expeditee.io.Conversion;
import org.expeditee.io.DefaultFrameWriter;
import org.expeditee.items.Item;
import org.expeditee.items.Line;
import org.expeditee.items.Text;

public class Surrogate {
        
        private static List<Surrogate> surrogateCache = new ArrayList<Surrogate>();
        
        private static Map<String, Boolean> propertyInheritanceDefault = new HashMap<String, Boolean>();
        
        {
                for (Character tag: DefaultFrameWriter.getItemTags().keySet()) {
                        if (tag == 'T') {
                                propertyInheritanceDefault.put(tag + "", false);
                        } else {
                                propertyInheritanceDefault.put(tag + "", true);
                        }
                }
                
                for (String tag: DefaultFrameWriter.getItemTagsExt().keySet()) {
                        propertyInheritanceDefault.put(tag, true);
                }
        }
        
        private Item surrogateItem = null;
        private Map<String, Boolean> propertyInheritance;
                
        public Surrogate(Item surrogateItem) {
                this.surrogateItem = surrogateItem;
                this.propertyInheritance = new HashMap<String, Boolean>(propertyInheritanceDefault);
                surrogateCache.add(this);
        }
        
        public String toString() {
                String nl = System.getProperty("line.separator");
                List<String> lines = toStringList();
                return lines.stream().map(l -> l + nl).reduce("", (acc, l) -> acc + l);
        }
        
        public List<String> toStringList() {
                List<String> lines = new ArrayList<String>();
                Map<Character,Method> itemTags = new LinkedHashMap<Character, Method>(DefaultFrameWriter.getItemTags());
                Map<String,Method> itemTagsExt = new LinkedHashMap<String, Method>(DefaultFrameWriter.getItemTagsExt());
                
                try {
                        Method methodS = itemTags.get('S');
                        Object o = methodS.invoke(surrogateItem);
                        o = Conversion.ConvertToExpeditee(methodS, o);
                        lines.add("S " + o);
                        lines.add("SurrogateFor " + surrogateItem.getClassic().getID());
                } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
                        e.printStackTrace();
                }
                itemTags.remove('S');
                itemTagsExt.remove("_el");
                
                
                for(Character itemTag: itemTags.keySet()) {
                        boolean propertyIsInherited = isPropertyIsInherited(itemTag + "");
                        if (propertyIsInherited) {
                                surrogateItem.getClassic().setEncryptionDetailForTag(itemTag + "", EncryptionDetail.UnencryptedOnSave);
                                continue;
                        }
                        
                        Object value = null;
                        if (itemTag == 'T') {
                                value = "REDACTED";
                        } else {
                                try {
                                        Method method = itemTags.get(itemTag);
                                        Object o = method.invoke(surrogateItem);
                                        value = Conversion.ConvertToExpeditee(method, o); 
                                } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
                                        e.printStackTrace();
                                }
                        }
                        lines.add(itemTag + " " + value);
                }
                for (String itemTag: itemTagsExt.keySet()) {
                        boolean propertyIsInherited = isPropertyIsInherited(itemTag);
                        if (propertyIsInherited) {
                                continue;
                        }
                        try {
                                Method method = itemTagsExt.get(itemTag);
                                Object o = method.invoke(surrogateItem);
                                o = Conversion.ConvertToExpeditee(method, o);
                                lines.add(itemTag + " " + o);
                        } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
                                e.printStackTrace();
                        }
                }
                
                return lines;
        }
        
        public Item getSurrogateItem() {
                return surrogateItem;
        }
        
        public boolean isPropertyIsInherited(String tag) {
                if (this.propertyInheritance.containsKey(tag)) {
                        return this.propertyInheritance.get(tag);
                } else {
                        return false;
                }
        }
        
        public void setPropertyIsInherited(String tag, boolean value) {
                this.propertyInheritance.put(tag, value);
        }
        
        public static Surrogate of(Item surrogate) {
                Optional<Surrogate> s = surrogateCache.stream().filter(si -> si.getSurrogateItem() == surrogate).findAny();
                if (s.isPresent()) {
                        return s.get();
                } else {
                        return null;
                }
        }
        
        public static Surrogate forItem(Item item) {            
                Item surrogateItem = item.copy();
                surrogateItem.setID(item.getParent().getNextItemID());
                surrogateItem.setAsSurrogateFor(item);
                
                if (item.isLineEnd()) {
                        handleLineEnd(surrogateItem);
                }
                
                if (surrogateItem instanceof Text && !surrogateItem.isAnnotation()) {
                        surrogateItem.setText("REDACTED");
                }
                
                Surrogate surrogate = new Surrogate(surrogateItem);
                item.addToSurrogates(surrogate);
                return surrogate;
        }
        
        private static Surrogate forItem(Line line) {
                Item startItem = line.getStartItem();
                Item endItem = line.getEndItem();
                
                if (!startItem.isSurrogate()) {
                        Set<Surrogate> surrogates = startItem.getSurrogates();
                        surrogates.removeIf(surrogate -> !surrogate.surrogateItem.isLineEnd());
                        if (surrogates.isEmpty()) {
                                Surrogate surrogate = Surrogate.forItem(startItem);
                                startItem.addToSurrogates(surrogate);
                                startItem = surrogate.surrogateItem;
                        } else {
                                startItem = surrogates.stream().findFirst().get().surrogateItem;
                        }
                }
                
                if (!endItem.isSurrogate()) {
                        Set<Surrogate> surrogates = endItem.getSurrogates();
                        surrogates.removeIf(surrogate -> !surrogate.surrogateItem.isLineEnd());
                        if (endItem.getSurrogates().isEmpty()) {
                                Surrogate surrogate = Surrogate.forItem(endItem);
                                endItem.addToSurrogates(surrogate);
                                endItem = surrogate.surrogateItem;
                        } else {
                                endItem = endItem.getSurrogates().stream().findFirst().get().surrogateItem;
                        }
                }
                
                Line ret = new Line(startItem, endItem, line.getParent().getNextItemID());
                ret.setAsSurrogateFor(line);
                Surrogate surrogate = new Surrogate(ret);
                line.addToSurrogates(surrogate);
                return surrogate;
        }
                
        private static void handleLineEnd(Item lineEndSurrogate) {
                Item lineEndClassic = lineEndSurrogate.getClassic();
                List<Item> lines = new ArrayList<Item>(lineEndClassic.getLines());
                lines.removeIf(line -> !line.getSurrogates().isEmpty());
                
                for(Item line: lines) {
                        Surrogate.forItem((Line) line);
                }               
        }
}