/*
 *  Copyright (C) 2004-2012 Savoir-Faire Linux Inc.
 *
 *  Author: Alexandre Savard <alexandre.savard@gmail.com>
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *
 *  Additional permission under GNU GPL version 3 section 7:
 *
 *  If you modify this program, or any covered work, by linking or
 *  combining it with the OpenSSL project's OpenSSL library (or a
 *  modified version of that library), containing parts covered by the
 *  terms of the OpenSSL or SSLeay licenses, Savoir-Faire Linux Inc.
 *  grants you additional permission to convey the resulting work.
 *  Corresponding Source for a non-source form of such a combination
 *  shall include the source code for the parts of OpenSSL used as well
 *  as that of the covered work.
 */
package com.savoirfairelinux.sflphone.model;

import java.util.ArrayList;
import java.util.Random;

import android.content.Intent;
import android.os.Bundle;
import android.os.Environment;
import android.os.Parcel;
import android.os.Parcelable;
import android.os.RemoteException;
import android.util.Log;

import com.savoirfairelinux.sflphone.model.Account.AccountBuilder;
import com.savoirfairelinux.sflphone.model.CallContact.ContactBuilder;
import com.savoirfairelinux.sflphone.service.ISipService;

public class SipCall implements Parcelable {

    private static final String TAG = SipCall.class.getSimpleName();

    private String mCallID = "";
    private String mAccountID = "";
    private ArrayList<CallContact> contacts = new ArrayList<CallContact>();

    private int mCallType = state.CALL_TYPE_UNDETERMINED;
    private int mCallState = state.CALL_STATE_NONE;
    private int mMediaState = state.MEDIA_STATE_NONE;

    /************************
     * Construtors
     * 
     ***********************/

    private SipCall(Parcel in) {
        ArrayList<String> list = in.createStringArrayList();

        // Don't mess with this order!!!
        mCallID = list.get(0);
        mAccountID = list.get(1);
        // mDisplayName = list.get(2);
        // mPhone = list.get(3);
        // mEmail = list.get(4);
        // mRemoteContact = list.get(5);

        contacts = in.createTypedArrayList(CallContact.CREATOR);

        mCallType = in.readInt();
        mCallState = in.readInt();
        mMediaState = in.readInt();
    }

    // public SipCall(Intent call) {

    // }

    public SipCall(String id, String account, int call_type, int call_state, int media_state, ArrayList<CallContact> c) {
        mCallID = id;
        mAccountID = account;
        mCallType = call_type;
        mCallState = call_state;
        mMediaState = media_state;
        this.contacts = new ArrayList<CallContact>(c);
    }


    // public SipCall() {
    // }

    public interface state {
        public static final int CALL_TYPE_UNDETERMINED = 0;
        public static final int CALL_TYPE_INCOMING = 1;
        public static final int CALL_TYPE_OUTGOING = 2;

        public static final int CALL_STATE_NONE = 0;
        public static final int CALL_STATE_INCOMING = 1;
        public static final int CALL_STATE_RINGING = 2;
        public static final int CALL_STATE_CURRENT = 3;
        public static final int CALL_STATE_HUNGUP = 4;
        public static final int CALL_STATE_BUSY = 5;
        public static final int CALL_STATE_FAILURE = 6;
        public static final int CALL_STATE_HOLD = 7;
        public static final int CALL_STATE_UNHOLD = 8;

        public static final int MEDIA_STATE_NONE = 0; // No media currently
        public static final int MEDIA_STATE_ACTIVE = 1; // Media is active
        public static final int MEDIA_STATE_LOCAL_HOLD = 2; // Media is put on hold bu user
        public static final int MEDIA_STATE_REMOTE_HOLD = 3; // Media is put on hold by peer
        public static final int MEDIA_STATE_ERROR = 5; // Media is in error state
    }

    @Override
    public int describeContents() {
        return 0;
    }

    @Override
    public void writeToParcel(Parcel out, int flags) {
        ArrayList<String> list = new ArrayList<String>();

        // Don't mess with this order!!!
        list.add(mCallID);
        list.add(mAccountID);

        out.writeStringList(list);
        out.writeTypedList(contacts);
        out.writeInt(mCallType);
        out.writeInt(mCallState);
        out.writeInt(mMediaState);
    }

    public static final Parcelable.Creator<SipCall> CREATOR = new Parcelable.Creator<SipCall>() {
        public SipCall createFromParcel(Parcel in) {
            return new SipCall(in);
        }

        public SipCall[] newArray(int size) {
            return new SipCall[size];
        }
    };

    public void setCallID(String callID) {
        mCallID = callID;
    }

    public String getCallId() {
        return mCallID;
    }

    public void setAccountID(String accountID) {
        mAccountID = accountID;
    }

    public String getAccountID() {
        return mAccountID;
    }

    public void setCallType(int callType) {
        mCallType = callType;
    }

    public int getCallType() {
        return mCallType;
    }

    public void setCallState(int callState) {
        mCallState = callState;
    }

    public int getCallStateInt() {
        return mCallState;
    }

    public String getmCallID() {
        return mCallID;
    }

    public void setmCallID(String mCallID) {
        this.mCallID = mCallID;
    }

    public String getmAccountID() {
        return mAccountID;
    }

    public void setmAccountID(String mAccountID) {
        this.mAccountID = mAccountID;
    }

    public ArrayList<CallContact> getContacts() {
        return contacts;
    }

    public void setContacts(ArrayList<CallContact> contacts) {
        this.contacts = contacts;
    }

    public int getmCallType() {
        return mCallType;
    }

    public void setmCallType(int mCallType) {
        this.mCallType = mCallType;
    }

    public int getmCallState() {
        return mCallState;
    }

    public void setmCallState(int mCallState) {
        this.mCallState = mCallState;
    }

    public int getmMediaState() {
        return mMediaState;
    }

    public void setmMediaState(int mMediaState) {
        this.mMediaState = mMediaState;
    }

    public String getCallStateString() {

        String text_state;

        switch (mCallState) {
        case state.CALL_STATE_INCOMING:
            text_state = "INCOMING";
            break;
        case state.CALL_STATE_RINGING:
            text_state = "RINGING";
            break;
        case state.CALL_STATE_CURRENT:
            text_state = "CURRENT";
            break;
        case state.CALL_STATE_HUNGUP:
            text_state = "HUNGUP";
            break;
        case state.CALL_STATE_BUSY:
            text_state = "BUSY";
            break;
        case state.CALL_STATE_FAILURE:
            text_state = "FAILURE";
            break;
        case state.CALL_STATE_HOLD:
            text_state = "HOLD";
            break;
        case state.CALL_STATE_UNHOLD:
            text_state = "UNHOLD";
            break;
        default:
            text_state = "NULL";
        }

        return text_state;
    }

    public void setMediaState(int mediaState) {
        mMediaState = mediaState;
    }

    public int getMediaState() {
        return mMediaState;
    }

    public boolean notifyServiceAnswer(ISipService service) {
        int callState = getCallStateInt();
        if ((callState != state.CALL_STATE_RINGING) && (callState != state.CALL_STATE_NONE)) {
            return false;
        }

        try {
            service.accept(mCallID);
        } catch (RemoteException e) {
            Log.e(TAG, "Cannot call service method", e);
        }

        return true;
    }

    /**
     * Perform hangup action without sending request to the service Used when SipService haved been notified that this call hung up
     */
    // public void hangupUpdateUi() {
    // Log.i(TAG, "Hangup call " + mCallID);
    //
    // if(mCallElementList != null)
    // mCallElementList.removeCall(this);
    //
    // if(mHome != null)
    // mHome.onUnselectedCallAction();
    // }

    public static class SipCallBuilder {

        private String bCallID = "";
        private String bAccountID = "";
        private ArrayList<CallContact> bContacts = new ArrayList<CallContact>();

        private int bCallType = state.CALL_TYPE_UNDETERMINED;
        private int bCallState = state.CALL_STATE_NONE;
        private int bMediaState = state.MEDIA_STATE_NONE;


        public SipCallBuilder setCallType(int bCallType) {
            this.bCallType = bCallType;
            return this;
        }

        public SipCallBuilder setMediaState(int state) {
            this.bMediaState = state;
            return this;
        }

        public SipCallBuilder setCallState(int state) {
            this.bCallState = state;
            return this;
        }
        
        private static final String TAG = SipCallBuilder.class.getSimpleName();
        
        public SipCallBuilder startCallCreation(String id) {
            bCallID = id;
            bContacts = new ArrayList<CallContact>();
            bCallType = SipCall.state.CALL_TYPE_INCOMING;
            return this;
        }

        public SipCallBuilder startCallCreation() {
            Random random = new Random();
            bCallID = Integer.toString(random.nextInt());
            bContacts = new ArrayList<CallContact>();
            return this;
        }

        public SipCallBuilder setAccountID(String h) {
            Log.i(TAG, "setAccountID" + h);
            bAccountID = h;
            return this;
        }

        public SipCallBuilder addContact(CallContact c) {
            bContacts.add(c);
            return this;
        }

        public SipCall build() throws Exception {
            if (bCallID.contentEquals("") || bAccountID.contentEquals("") || bContacts.size() == 0) {
                throw new Exception("SipCallBuilder's parameters missing");
            }
            return new SipCall(bCallID, bAccountID, bCallType, bCallState, bMediaState, bContacts);
        }

        public static SipCallBuilder getInstance() {
            return new SipCallBuilder();
        }


    }

    /**
     * Perform hangup action and send request to the service
     */
    public boolean notifyServiceHangup(ISipService service) {
        try {
            if ((getCallStateInt() == state.CALL_STATE_NONE) || (getCallStateInt() == state.CALL_STATE_CURRENT)
                    || (getCallStateInt() == state.CALL_STATE_HOLD)) {
                service.hangUp(mCallID);
                return true;

            } else if (getCallStateInt() == state.CALL_STATE_RINGING) {
                if (getCallType() == state.CALL_TYPE_INCOMING) {
                    service.refuse(mCallID);
                    return true;
                } else if (getCallType() == state.CALL_TYPE_OUTGOING) {
                    service.hangUp(mCallID);
                    return true;
                }
            }
        } catch (RemoteException e) {
            Log.e(TAG, "Cannot call service method", e);
        }

        return false;
    }

    public boolean notifyServiceRefuse(ISipService service) {
        try {
            if (getCallStateInt() == state.CALL_STATE_RINGING) {
                service.refuse(mCallID);
                return true;
            }
        } catch (RemoteException e) {
            Log.e(TAG, "Cannot call service method", e);
        }

        return false;
    }

    public boolean notifyServiceHold(ISipService service) {
        try {
            if (getCallStateInt() == state.CALL_STATE_CURRENT) {
                service.hold(mCallID);
                return true;
            }
        } catch (RemoteException e) {
            Log.e(TAG, "Cannot call service method", e);
        }

        return false;
    }

    public boolean notifyServiceUnhold(ISipService service) {
        try {
            if (getCallStateInt() == state.CALL_STATE_HOLD) {
                service.unhold(mCallID);
                return true;
            }
        } catch (RemoteException e) {
            Log.e(TAG, "Cannot call service method", e);
        }

        return false;
    }

    public void addToConference() {
        Log.i(TAG, "Add call to conference");
    }

    public void sendTextMessage() {
        Log.i(TAG, "Send text message");
    }

    // public void printCallInfo() {
    // Log.i(TAG, "CallInfo: CallID: " + mCallID);
    // Log.i(TAG, "          AccountID: " + mAccountID);
    // Log.i(TAG, "          Display Name: " + mDisplayName);
    // Log.i(TAG, "          Phone: " + mPhone);
    // Log.i(TAG, "          Email: " + mEmail);
    // Log.i(TAG, "          Contact: " + mRemoteContact);
    // }

    /**
     * Compare sip calls based on call ID
     */
    @Override
    public boolean equals(Object c) {
        if (c instanceof SipCall && ((SipCall) c).mCallID == mCallID) {
            return true;
        }
        return false;

    }

    public void notifyServiceTransfer(ISipService service, String to) {
        try {
            if (getCallStateInt() == state.CALL_STATE_CURRENT) {
                service.transfer(mCallID, to);
            }
        } catch (RemoteException e) {
            Log.e(TAG, "Cannot call service method", e);
        }
    }

    public void notifyServiceRecord(ISipService service) {
        try {
            if (getCallStateInt() == state.CALL_STATE_CURRENT) {
                service.setRecordPath(Environment.getExternalStorageDirectory().getAbsolutePath());
                Log.w(TAG, "Recording path" + service.getRecordPath());
                service.setRecordingCall(mCallID);
            }
        } catch (RemoteException e) {
            Log.e(TAG, "Cannot call service method", e);
        }

    }

    // public void notifyServiceSendMsg(ISipService service, String msg) {
    // try {
    // if (getCallStateInt() == state.CALL_STATE_CURRENT) {
    // service.sendTextMessage(mCallID, msg, mDisplayName);
    // }
    // } catch (RemoteException e) {
    // Log.e(TAG, "Cannot call service method", e);
    // }
    //
    // }
}