package alice.codesegment;

import alice.datasegment.CommandType;
import alice.datasegment.DataSegment;
import alice.datasegment.ReceiveData;
import alice.datasegment.Receiver;
import alice.datasegment.SendOption;

public class OutputDataSegment {
    private boolean compressFlag = false;//圧縮するかどうか

    /**
     * for local
     */

    /**
     * input→ds変更→outputのときコピーを防ぐ
     */
    public void flip(Receiver receiver) {
        if (receiver.isCompressed()){
            DataSegment.getCompressedLocal().put(receiver.key, receiver.getReceiveData(), false);
        } else {
            DataSegment.getLocal().put(receiver.key, receiver.getReceiveData(), false);
        }
    }

    public void flip(Receiver receiver, CommandType type) {
        switch (type) {
        case PUT:
            if (receiver.isCompressed()){
                DataSegment.getCompressedLocal().put(receiver.key, receiver.getReceiveData(), false);//localなら全部false。
            } else {
                DataSegment.getLocal().put(receiver.key, receiver.getReceiveData(), false);
            }
            break;
        case UPDATE:
            if (receiver.isCompressed()){
                DataSegment.getCompressedLocal().update(receiver.key, receiver.getReceiveData(), false);
            } else {
                DataSegment.getLocal().update(receiver.key, receiver.getReceiveData(), false);
            }

            break;
        default:
            break;
        }
    }

    public void put(String key, ReceiveData rData) {
        DataSegment.getLocal().put(key, rData, false);
    }

    public void put(String key, Object val) {
        ReceiveData rData = new ReceiveData(val);
        DataSegment.getLocal().put(key, rData, false);
    }

    public void put(String key, Object val, boolean cFlag) {//追加
        ReceiveData rData = new ReceiveData(val);
        rData.setCompressFlag(cFlag);
        DataSegment.getLocal().put(key, rData, false);
    }

    public void update(String key, Object val) {
        ReceiveData rData = new ReceiveData(val);
        DataSegment.getLocal().update(key, rData, false);
    }

    public void update(String key, Object val, boolean cFlag) {//追加
        ReceiveData rData = new ReceiveData(val);
        rData.setCompressFlag(cFlag);
        DataSegment.getLocal().update(key, rData, false);
    }

    /**
     * for remote
     */
    public void put(String managerKey, String key, ReceiveData rData) {
        if (!managerKey.equals("local") && DataSegment.contains(managerKey)){
            if (rData.compressed()){
                DataSegment.get(managerKey + "!").put(key, rData, false);
            } else {
                DataSegment.get(managerKey).put(key, rData, false);
            }

        } else {
            put(key, rData);
        }
    }

    public void put(String managerKey, String key, Object val) {
        put(managerKey, key, val, false);
    }

    public void put(String managerKey, String key, Object val, boolean cFlag) {//追加
        System.out.println("in PUT");
        ReceiveData rData = new ReceiveData(val);
        rData.setCompressFlag(cFlag);

        if (!managerKey.equals("local") && DataSegment.contains(managerKey)){///if remote
            if (cFlag){
                DataSegment.get(managerKey + "!").put(key, rData, false);
            } else {
                DataSegment.get(managerKey).put(key, rData, false);
            }
        } else {// if local
            if (cFlag){
                DataSegment.getCompressedLocal().put(key, rData, false);
            } else {
                put(key, val);
            }
        }



    }

    public void quickPut(String managerKey, String key, ReceiveData rData) {
        if (!managerKey.equals("local") && DataSegment.contains(managerKey)){
            if (rData.compressed()){
                DataSegment.get(managerKey + "!").put(key, rData, true);
            } else {
                DataSegment.get(managerKey).put(key, rData, true);
            }
        } else {
            put(key, rData);
        }
    }

    public void quickPut(String managerKey, String key, Object val) {
        quickPut(managerKey, key, val, false);
    }

    public void quickPut(String managerKey, String key, Object val, boolean cFlag) {//追加
        if (!managerKey.equals("local") && DataSegment.contains(managerKey)){
            ReceiveData rData = new ReceiveData(val);
            rData.setCompressFlag(cFlag);
            if (cFlag){
                DataSegment.get(managerKey + "!").put(key, rData, true);
            } else {
                DataSegment.get(managerKey).put(key, rData, true);
            }
        } else {
            put(key, val);
        }
    }

    public void update(String managerKey, String key, ReceiveData rData) {
        if (!managerKey.equals("local") && DataSegment.contains(managerKey)){
            if (rData.compressed()){
                DataSegment.get(managerKey + "!").update(key, rData, false);
            } else {
                DataSegment.get(managerKey).update(key, rData, false);
            }
        } else {
            update(key, rData);
        }
    }

    public void update(String managerKey, String key, Object val) {
        update(managerKey, key, val, false);
    }

    public void update(String managerKey, String key, Object val, boolean cFlag) {//追加
        if (!managerKey.equals("local") && DataSegment.contains(managerKey)){
            ReceiveData rData = new ReceiveData(val);
            rData.setCompressFlag(cFlag);
            if(cFlag){
                DataSegment.get(managerKey + "!").update(key, rData, false);
            } else {
                DataSegment.get(managerKey).update(key, rData, false);
            }
        } else {
            update(key, val);
        }
    }

    public void quickUpdate(String managerKey, String key, ReceiveData rData) {
        if (!managerKey.equals("local") && DataSegment.contains(managerKey)){
            if (rData.compressed()){
                DataSegment.get(managerKey + "!").update(key, rData, true);
            } else {
                DataSegment.get(managerKey).update(key, rData, true);
            }
        } else {
            update(key, rData);
        }
    }

    public void quickUpdate(String managerKey, String key, Object val) {
        quickUpdate(managerKey, key, val, false);
    }

    public void quickUpdate(String managerKey, String key, Object val, boolean cFlag) {//追加
        if (!managerKey.equals("local") && DataSegment.contains(managerKey)){
            ReceiveData rData = new ReceiveData(val);
            rData.setCompressFlag(cFlag);
            if (cFlag){
                DataSegment.get(managerKey + "!").update(key, rData, true);
            } else {
                DataSegment.get(managerKey).update(key, rData, true);
            }
        } else {
            update(key, val);
        }
    }

    /**
     * kill the Alice process after send other messages.
     *
     * @param managerKey
     */

    public void finish(String managerKey) {
        if (DataSegment.contains(managerKey))
            DataSegment.get(managerKey).finish();
    }

    /**
     * close socket for RemoteDataSegment after send other messages.
     *
     * @param managerKey
     */

    public void close(String managerKey) {
        if (DataSegment.contains(managerKey))
            DataSegment.get(managerKey).close();
    }

    /**
     * "key" is not remote DataSegment's key.
     * "Ping Response" return in this "key"
     *
     * @param managerKey
     * @param returnKey
     */
    public void ping(String managerKey, String returnKey) {
        if (DataSegment.contains(managerKey))
            DataSegment.get(managerKey).ping(returnKey);
    }

    public boolean compressFlag() {
        return compressFlag;
    }

    public void setCompressFlag(boolean cFlag) {
        compressFlag = cFlag;
    }
}