EDIT

/**

* Copyright (C) 2018 EDIT

* European Distributed Institute of Taxonomy

* http://www.e-taxonomy.eu

*

* The contents of this file are subject to the Mozilla Public License Version 1.1

* See LICENSE.TXT at the top of this package for the full license terms.

*/

package eu.etaxonomy.taxeditor.featuretree;

import java.io.ByteArrayInputStream;

import java.io.ByteArrayOutputStream;

import java.io.DataInputStream;

import java.io.DataOutputStream;

import java.io.EOFException;

import java.io.IOException;

import java.util.ArrayList;

import java.util.Collection;

import java.util.List;

import java.util.UUID;

import org.eclipse.swt.dnd.ByteArrayTransfer;

import org.eclipse.swt.dnd.TransferData;

import eu.etaxonomy.cdm.api.service.IFeatureNodeService;

import eu.etaxonomy.cdm.model.common.Language;

import eu.etaxonomy.cdm.model.description.Character;

import eu.etaxonomy.cdm.model.term.DefinedTerm;

import eu.etaxonomy.cdm.model.term.Representation;

import eu.etaxonomy.cdm.model.term.TermNode;

import eu.etaxonomy.taxeditor.preference.PreferencesUtil;

import eu.etaxonomy.taxeditor.store.CdmStore;

/**

 * @author pplitzner

 * @since Nov 30, 2018

 *

 */

public class CharacterTransfer extends ByteArrayTransfer {

    private static CharacterTransfer instance = new CharacterTransfer();

    private static final String TYPE_NAME = "characters-transfer-format";

    private static final int TYPEID = registerType(TYPE_NAME);

    public static synchronized CharacterTransfer getInstance() {

        return instance;

    }

    private CharacterTransfer() {

    }

    @Override

    protected int[] getTypeIds() {

        return new int[] { TYPEID };

    }

    @Override

    protected String[] getTypeNames() {

        return new String[] { TYPE_NAME };

    }

    @Override

    protected void javaToNative(Object object, TransferData transferData) {

        if (object != null){

            Collection<Character> characters = (Collection<Character>)object;

            ByteArrayOutputStream byteOut = new ByteArrayOutputStream();

            DataOutputStream out = new DataOutputStream(byteOut);

            byte[] bytes = null;

            try {

                for(Character character : characters){

                    out.writeUTF(character.getStructure().getUuid().toString()

                            +","

                            +character.getProperty().getUuid().toString());

                }

                out.close();

                bytes = byteOut.toByteArray();

            } catch (IOException e) {

                // when in doubt send nothing

            }

            if (bytes != null) {

                super.javaToNative(bytes, transferData);

            }

        }

    }

    @Override

    protected Object nativeToJava(TransferData transferData) {

        byte[] bytes = (byte[]) super.nativeToJava(transferData);

        if (bytes != null){

            DataInputStream in = new DataInputStream(

                    new ByteArrayInputStream(bytes));

            try {

                List<Character> characters = new ArrayList<>();

                try{

                    while(true){

                        String string = in.readUTF();

                        String[] split = string.split(",");

                        IFeatureNodeService featureNodeService = CdmStore.getService(IFeatureNodeService.class);

                        TermNode<DefinedTerm> structure = featureNodeService.load(UUID.fromString(split[0]));

                        TermNode<DefinedTerm> property = featureNodeService.load(UUID.fromString(split[1]));

                        characters.add(createCharacter(structure, property));

                    }

                }catch(EOFException e){

                    return characters.toArray();

                }

            } catch (IOException e) {

                return null;

            }

        }

        return null;

    }

    public static Character createCharacter(TermNode<DefinedTerm> structureNode,

            TermNode<DefinedTerm> propertyNode) {

        Representation structureRepresentation = structureNode.getTerm().getRepresentation(PreferencesUtil.getGlobalLanguage());

        if(structureRepresentation==null){

            structureRepresentation = structureNode.getTerm().getRepresentation(Language.DEFAULT());

        }

        Representation propertyRepresentation = propertyNode.getTerm().getRepresentation(PreferencesUtil.getGlobalLanguage());

        if(propertyRepresentation==null){

            propertyRepresentation = propertyNode.getTerm().getRepresentation(Language.DEFAULT());

        }

        String label = null;

        String abbrevLabel = null;

        if(structureRepresentation!=null && propertyRepresentation!=null){

            if(structureRepresentation.getLabel()!=null && propertyRepresentation.getLabel()!=null){

                label = structureRepresentation.getLabel()+" "+propertyRepresentation.getLabel();

            }

            if(structureRepresentation.getAbbreviatedLabel()!=null && propertyRepresentation.getAbbreviatedLabel()!=null){

                abbrevLabel = structureRepresentation.getAbbreviatedLabel()+" "+propertyRepresentation.getAbbreviatedLabel();

            }

        }

        if(label!=null){

            //default label

            label = structureNode.getTerm().getLabel()+" "+propertyNode.getTerm().getLabel();

        }

        //create new Character

        Character character = Character.NewInstance(structureNode, propertyNode, null, label, abbrevLabel);

        return character;

    }

}