/*
 * Copyright (c) 2017 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

/*
 * Defines the native inteface that is used by state machine/service to either or receive messages
 * from the native stack. This file is registered for the native methods in corresponding CPP file.
 */
package com.android.bluetooth.hfpclient;

import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothDevice;
import android.util.Log;

import com.android.internal.annotations.VisibleForTesting;

/**
 * Defines native calls that are used by state machine/service to either send or receive
 * messages to/from the native stack. This file is registered for the native methods in
 * corresponding CPP file.
 */
public class NativeInterface {
    private static final String TAG = "NativeInterface";
    private static final boolean DBG = false;

    static {
        classInitNative();
    }

    private NativeInterface() {}
    private static NativeInterface sInterface;
    private static final Object INSTANCE_LOCK = new Object();

    /**
     * This class is a singleton because native library should only be loaded once
     *
     * @return default instance
     */
    public static NativeInterface getInstance() {
        synchronized (INSTANCE_LOCK) {
            if (sInterface == null) {
                sInterface = new NativeInterface();
            }
        }
        return sInterface;
    }

    // Native wrappers to help unit testing
    /**
     * Initialize native stack
     */
    @VisibleForTesting
    public void initialize() {
        initializeNative();
    }

    /**
     * Close and clean up native stack
     */
    @VisibleForTesting
    public void cleanup() {
        cleanupNative();
    }

    /**
     * Connect to the specified paired device
     *
     * @param address target device's address
     * @return True on success, False on failure
     */
    @VisibleForTesting
    public boolean connect(byte[] address) {
        return connectNative(address);
    }

    /**
     * Disconnect from the specified paired device
     *
     * @param address target device's address
     * @return True on success, False on failure
     */
    @VisibleForTesting
    public boolean disconnect(byte[] address) {
        return disconnectNative(address);
    }

    /**
     * Initiate audio connection to the specified paired device
     *
     * @param address target device's address
     * @return True on success, False on failure
     */
    @VisibleForTesting
    public boolean connectAudio(byte[] address) {
        return connectAudioNative(address);
    }

    /**
     * Close audio connection from the specified paired device
     *
     * @param address target device's address
     * @return True on success, False on failure
     */
    public boolean disconnectAudio(byte[] address) {
        return disconnectAudioNative(address);
    }

    /**
     * Initiate voice recognition to the specified paired device
     *
     * @param address target device's address
     * @return True on success, False on failure
     */
    @VisibleForTesting
    public boolean startVoiceRecognition(byte[] address) {
        return startVoiceRecognitionNative(address);
    }

    /**
     * Close voice recognition to the specified paired device
     *
     * @param address target device's address
     * @return True on success, False on failure
     */
    @VisibleForTesting
    public boolean stopVoiceRecognition(byte[] address) {
        return stopVoiceRecognitionNative(address);
    }

    /**
     * Set volume to the specified paired device
     *
     * @param volumeType type of volume as in
     *                  HeadsetClientHalConstants.VOLUME_TYPE_xxxx
     * @param volume  volume level
     * @param address target device's address
     * @return True on success, False on failure
     */
    @VisibleForTesting
    public boolean setVolume(byte[] address, int volumeType, int volume) {
        return setVolumeNative(address, volumeType, volume);
    }

    /**
     * dial number from the specified paired device
     *
     * @param number  phone number to be dialed
     * @param address target device's address
     * @return True on success, False on failure
     */
    @VisibleForTesting
    public boolean dial(byte[] address, String number) {
        return dialNative(address, number);
    }

    /**
     * Memory dialing from the specified paired device
     *
     * @param location  memory location
     * @param address target device's address
     * @return True on success, False on failure
     */
    @VisibleForTesting
    public boolean dialMemory(byte[] address, int location) {
        return dialMemoryNative(address, location);
    }

    /**
     * Apply action to call
     *
     * @action action (e.g. hold, terminate etc)
     * @index call index
     * @param address target device's address
     * @return True on success, False on failure
     */
    @VisibleForTesting
    public boolean handleCallAction(byte[] address, int action, int index) {
        return handleCallActionNative(address, action, index);
    }

    /**
     * Query current call status from the specified paired device
     *
     * @param address target device's address
     * @return True on success, False on failure
     */
    @VisibleForTesting
    public boolean queryCurrentCalls(byte[] address) {
        return queryCurrentCallsNative(address);
    }

    /**
     * Query operator name from the specified paired device
     *
     * @param address target device's address
     * @return True on success, False on failure
     */
    @VisibleForTesting
    public boolean queryCurrentOperatorName(byte[] address) {
        return queryCurrentOperatorNameNative(address);
    }

    /**
     * Retrieve subscriber number from the specified paired device
     *
     * @param address target device's address
     * @return True on success, False on failure
     */
    @VisibleForTesting
    public  boolean retrieveSubscriberInfo(byte[] address) {
        return retrieveSubscriberInfoNative(address);
    }

    /**
     * Transmit DTMF code
     *
     * @param code DTMF code
     * @param address target device's address
     * @return True on success, False on failure
     */
    @VisibleForTesting
    public boolean sendDtmf(byte[] address, byte code) {
        return sendDtmfNative(address, code);
    }

    /**
     * Request last voice tag
     *
     * @param address target device's address
     * @return True on success, False on failure
     */
    @VisibleForTesting
    public boolean requestLastVoiceTagNumber(byte[] address) {
        return requestLastVoiceTagNumberNative(address);
    }

    /**
     * Send an AT command
     *
     * @param atCmd command code
     * @param val1 command specific argurment1
     * @param val2 command specific argurment2
     * @param arg other command specific argurments
     * @return True on success, False on failure
     */
    @VisibleForTesting
    public boolean sendATCmd(byte[] address, int atCmd, int val1, int val2, String arg) {
        return sendATCmdNative(address, atCmd, val1, val2, arg);
    }

    // Native methods that call into the JNI interface
    private static native void classInitNative();

    private native void initializeNative();

    private native void cleanupNative();

    private static native boolean connectNative(byte[] address);

    private static native boolean disconnectNative(byte[] address);

    private static native boolean connectAudioNative(byte[] address);

    private static native boolean disconnectAudioNative(byte[] address);

    private static native boolean startVoiceRecognitionNative(byte[] address);

    private static native boolean stopVoiceRecognitionNative(byte[] address);

    private static native boolean setVolumeNative(byte[] address, int volumeType, int volume);

    private static native boolean dialNative(byte[] address, String number);

    private static native boolean dialMemoryNative(byte[] address, int location);

    private static native boolean handleCallActionNative(byte[] address, int action, int index);

    private static native boolean queryCurrentCallsNative(byte[] address);

    private static native boolean queryCurrentOperatorNameNative(byte[] address);

    private static native boolean retrieveSubscriberInfoNative(byte[] address);

    private static native boolean sendDtmfNative(byte[] address, byte code);

    private static native boolean requestLastVoiceTagNumberNative(byte[] address);

    private static native boolean sendATCmdNative(byte[] address, int atCmd, int val1, int val2,
            String arg);

    private BluetoothDevice getDevice(byte[] address) {
        return BluetoothAdapter.getDefaultAdapter().getRemoteDevice(address);
    }

    // Callbacks from the native back into the java framework. All callbacks are routed via the
    // Service which will disambiguate which state machine the message should be routed through.
    private void onConnectionStateChanged(int state, int peerFeat, int chldFeat, byte[] address) {
        StackEvent event = new StackEvent(StackEvent.EVENT_TYPE_CONNECTION_STATE_CHANGED);
        event.valueInt = state;
        event.valueInt2 = peerFeat;
        event.valueInt3 = chldFeat;
        event.device = getDevice(address);
        // BluetoothAdapter.getDefaultAdapter().getRemoteDevice(Utils.getAddressStringFromByte
        // (address));
        if (DBG) {
            Log.d(TAG, "Device addr " + event.device.getAddress() + " State " + state);
        }
        HeadsetClientService service = HeadsetClientService.getHeadsetClientService();
        if (service != null) {
            service.messageFromNative(event);
        } else {
            Log.w(TAG, "Ignoring message because service not available: " + event);
        }
    }

    private void onAudioStateChanged(int state, byte[] address) {
        StackEvent event = new StackEvent(StackEvent.EVENT_TYPE_AUDIO_STATE_CHANGED);
        event.valueInt = state;
        event.device = getDevice(address);
        if (DBG) {
            Log.d(TAG, "onAudioStateChanged: address " + address + " event " + event);
        }
        HeadsetClientService service = HeadsetClientService.getHeadsetClientService();
        if (service != null) {
            service.messageFromNative(event);
        } else {
            Log.w(TAG, "onAudioStateChanged: Ignoring message because service not available: "
                    + event);
        }
    }

    private void onVrStateChanged(int state, byte[] address) {
        StackEvent event = new StackEvent(StackEvent.EVENT_TYPE_VR_STATE_CHANGED);
        event.valueInt = state;
        event.device = getDevice(address);
        if (DBG) {
            Log.d(TAG, "onVrStateChanged: address " + address + " event " + event);
        }

        HeadsetClientService service = HeadsetClientService.getHeadsetClientService();
        if (service != null) {
            service.messageFromNative(event);
        } else {
            Log.w(TAG,
                    "onVrStateChanged: Ignoring message because service not available: " + event);
        }
    }

    private void onNetworkState(int state, byte[] address) {
        StackEvent event = new StackEvent(StackEvent.EVENT_TYPE_NETWORK_STATE);
        event.valueInt = state;
        event.device = getDevice(address);
        if (DBG) {
            Log.d(TAG, "onNetworkStateChanged: address " + address + " event " + event);
        }

        HeadsetClientService service = HeadsetClientService.getHeadsetClientService();
        if (service != null) {
            service.messageFromNative(event);
        } else {
            Log.w(TAG,
                    "onNetworkStateChanged: Ignoring message because service not available: "
                            + event);
        }
    }

    private void onNetworkRoaming(int state, byte[] address) {
        StackEvent event = new StackEvent(StackEvent.EVENT_TYPE_ROAMING_STATE);
        event.valueInt = state;
        event.device = getDevice(address);
        if (DBG) {
            Log.d(TAG, "onNetworkRoaming: incoming: " + event);
        }
        HeadsetClientService service = HeadsetClientService.getHeadsetClientService();
        if (service != null) {
            service.messageFromNative(event);
        } else {
            Log.w(TAG,
                    "onNetworkRoaming: Ignoring message because service not available: " + event);
        }
    }

    private void onNetworkSignal(int signal, byte[] address) {
        StackEvent event = new StackEvent(StackEvent.EVENT_TYPE_NETWORK_SIGNAL);
        event.valueInt = signal;
        event.device = getDevice(address);
        if (DBG) {
            Log.d(TAG, "onNetworkSignal: address " + address + " event " + event);
        }
        HeadsetClientService service = HeadsetClientService.getHeadsetClientService();
        if (service != null) {
            service.messageFromNative(event);
        } else {
            Log.w(TAG, "onNetworkSignal: Ignoring message because service not available: " + event);
        }
    }

    private void onBatteryLevel(int level, byte[] address) {
        StackEvent event = new StackEvent(StackEvent.EVENT_TYPE_BATTERY_LEVEL);
        event.valueInt = level;
        event.device = getDevice(address);
        if (DBG) {
            Log.d(TAG, "onBatteryLevel: address " + address + " event " + event);
        }
        HeadsetClientService service = HeadsetClientService.getHeadsetClientService();
        if (service != null) {
            service.messageFromNative(event);
        } else {
            Log.w(TAG, "onBatteryLevel: Ignoring message because service not available: " + event);
        }
    }

    private void onCurrentOperator(String name, byte[] address) {
        StackEvent event = new StackEvent(StackEvent.EVENT_TYPE_OPERATOR_NAME);
        event.valueString = name;
        event.device = getDevice(address);
        if (DBG) {
            Log.d(TAG, "onCurrentOperator: address " + address + " event " + event);
        }
        HeadsetClientService service = HeadsetClientService.getHeadsetClientService();
        if (service != null) {
            service.messageFromNative(event);
        } else {
            Log.w(TAG,
                    "onCurrentOperator: Ignoring message because service not available: " + event);
        }
    }

    private void onCall(int call, byte[] address) {
        StackEvent event = new StackEvent(StackEvent.EVENT_TYPE_CALL);
        event.valueInt = call;
        event.device = getDevice(address);
        if (DBG) {
            Log.d(TAG, "onCall: address " + address + " event " + event);
        }
        HeadsetClientService service = HeadsetClientService.getHeadsetClientService();
        if (service != null) {
            service.messageFromNative(event);
        } else {
            Log.w(TAG, "onCall: Ignoring message because service not available: " + event);
        }
    }

    /**
     * CIEV (Call indicators) notifying if call(s) are getting set up.
     *
     * Values include:
     * 0 - No current call is in setup
     * 1 - Incoming call process ongoing
     * 2 - Outgoing call process ongoing
     * 3 - Remote party being alerted for outgoing call
     */
    private void onCallSetup(int callsetup, byte[] address) {
        StackEvent event = new StackEvent(StackEvent.EVENT_TYPE_CALLSETUP);
        event.valueInt = callsetup;
        event.device = getDevice(address);
        if (DBG) {
            Log.d(TAG, "onCallSetup: addr " + address + " device" + event.device);
            Log.d(TAG, "onCallSetup: address " + address + " event " + event);
        }
        HeadsetClientService service = HeadsetClientService.getHeadsetClientService();
        if (service != null) {
            service.messageFromNative(event);
        } else {
            Log.w(TAG, "onCallSetup: Ignoring message because service not available: " + event);
        }
    }

    /**
     * CIEV (Call indicators) notifying call held states.
     *
     * Values include:
     * 0 - No calls held
     * 1 - Call is placed on hold or active/held calls wapped (The AG has both an ACTIVE and HELD
     * call)
     * 2 - Call on hold, no active call
     */
    private void onCallHeld(int callheld, byte[] address) {
        StackEvent event = new StackEvent(StackEvent.EVENT_TYPE_CALLHELD);
        event.valueInt = callheld;
        event.device = getDevice(address);
        if (DBG) {
            Log.d(TAG, "onCallHeld: address " + address + " event " + event);
        }
        HeadsetClientService service = HeadsetClientService.getHeadsetClientService();
        if (service != null) {
            service.messageFromNative(event);
        } else {
            Log.w(TAG, "onCallHeld: Ignoring message because service not available: " + event);
        }
    }

    private void onRespAndHold(int respAndHold, byte[] address) {
        StackEvent event = new StackEvent(StackEvent.EVENT_TYPE_RESP_AND_HOLD);
        event.valueInt = respAndHold;
        event.device = getDevice(address);
        if (DBG) {
            Log.d(TAG, "onRespAndHold: address " + address + " event " + event);
        }
        HeadsetClientService service = HeadsetClientService.getHeadsetClientService();
        if (service != null) {
            service.messageFromNative(event);
        } else {
            Log.w(TAG, "onRespAndHold: Ignoring message because service not available: " + event);
        }
    }

    private void onClip(String number, byte[] address) {
        StackEvent event = new StackEvent(StackEvent.EVENT_TYPE_CLIP);
        event.valueString = number;
        event.device = getDevice(address);
        if (DBG) {
            Log.d(TAG, "onClip: address " + address + " event " + event);
        }
        HeadsetClientService service = HeadsetClientService.getHeadsetClientService();
        if (service != null) {
            service.messageFromNative(event);
        } else {
            Log.w(TAG, "onClip: Ignoring message because service not available: " + event);
        }
    }

    private void onCallWaiting(String number, byte[] address) {
        StackEvent event = new StackEvent(StackEvent.EVENT_TYPE_CALL_WAITING);
        event.valueString = number;
        event.device = getDevice(address);
        if (DBG) {
            Log.d(TAG, "onCallWaiting: address " + address + " event " + event);
        }
        HeadsetClientService service = HeadsetClientService.getHeadsetClientService();
        if (service != null) {
            service.messageFromNative(event);
        } else {
            Log.w(TAG, "onCallWaiting: Ignoring message because service not available: " + event);
        }
    }

    private void onCurrentCalls(int index, int dir, int state, int mparty, String number,
            byte[] address) {
        StackEvent event = new StackEvent(StackEvent.EVENT_TYPE_CURRENT_CALLS);
        event.valueInt = index;
        event.valueInt2 = dir;
        event.valueInt3 = state;
        event.valueInt4 = mparty;
        event.valueString = number;
        event.device = getDevice(address);
        if (DBG) {
            Log.d(TAG, "onCurrentCalls: address " + address + " event " + event);
        }
        HeadsetClientService service = HeadsetClientService.getHeadsetClientService();
        if (service != null) {
            service.messageFromNative(event);
        } else {
            Log.w(TAG, "onCurrentCalls: Ignoring message because service not available: " + event);
        }
    }

    private void onVolumeChange(int type, int volume, byte[] address) {
        StackEvent event = new StackEvent(StackEvent.EVENT_TYPE_VOLUME_CHANGED);
        event.valueInt = type;
        event.valueInt2 = volume;
        event.device = getDevice(address);
        if (DBG) {
            Log.d(TAG, "onVolumeChange: address " + address + " event " + event);
        }
        HeadsetClientService service = HeadsetClientService.getHeadsetClientService();
        if (service != null) {
            service.messageFromNative(event);
        } else {
            Log.w(TAG, "onVolumeChange: Ignoring message because service not available: " + event);
        }
    }

    private void onCmdResult(int type, int cme, byte[] address) {
        StackEvent event = new StackEvent(StackEvent.EVENT_TYPE_CMD_RESULT);
        event.valueInt = type;
        event.valueInt2 = cme;
        event.device = getDevice(address);
        if (DBG) {
            Log.d(TAG, "onCmdResult: address " + address + " event " + event);
        }
        HeadsetClientService service = HeadsetClientService.getHeadsetClientService();
        if (service != null) {
            service.messageFromNative(event);
        } else {
            Log.w(TAG, "onCmdResult: Ignoring message because service not available: " + event);
        }
    }

    private void onSubscriberInfo(String number, int type, byte[] address) {
        StackEvent event = new StackEvent(StackEvent.EVENT_TYPE_SUBSCRIBER_INFO);
        event.valueInt = type;
        event.valueString = number;
        event.device = getDevice(address);
        if (DBG) {
            Log.d(TAG, "onSubscriberInfo: address " + address + " event " + event);
        }
        HeadsetClientService service = HeadsetClientService.getHeadsetClientService();
        if (service != null) {
            service.messageFromNative(event);
        } else {
            Log.w(TAG,
                    "onSubscriberInfo: Ignoring message because service not available: " + event);
        }
    }

    private void onInBandRing(int inBand, byte[] address) {
        StackEvent event = new StackEvent(StackEvent.EVENT_TYPE_IN_BAND_RINGTONE);
        event.valueInt = inBand;
        event.device = getDevice(address);
        if (DBG) {
            Log.d(TAG, "onInBandRing: address " + address + " event " + event);
        }
        HeadsetClientService service = HeadsetClientService.getHeadsetClientService();
        if (service != null) {
            service.messageFromNative(event);
        } else {
            Log.w(TAG,
                    "onInBandRing: Ignoring message because service not available: " + event);
        }
    }

    private void onLastVoiceTagNumber(String number, byte[] address) {
        Log.w(TAG, "onLastVoiceTagNumber not supported");
    }

    private void onRingIndication(byte[] address) {
        StackEvent event = new StackEvent(StackEvent.EVENT_TYPE_RING_INDICATION);
        event.device = getDevice(address);
        if (DBG) {
            Log.d(TAG, "onRingIndication: address " + address + " event " + event);
        }
        HeadsetClientService service = HeadsetClientService.getHeadsetClientService();
        if (service != null) {
            service.messageFromNative(event);
        } else {
            Log.w(TAG,
                    "onRingIndication: Ignoring message because service not available: " + event);
        }
    }

    private void onUnknownEvent(String eventString, byte[] address) {
        StackEvent event = new StackEvent(StackEvent.EVENT_TYPE_UNKNOWN_EVENT);
        event.device = getDevice(address);
        event.valueString = eventString;
        if (DBG) {
            Log.d(TAG, "onUnknownEvent: address " + address + " event " + event);
        }
        HeadsetClientService service = HeadsetClientService.getHeadsetClientService();
        if (service != null) {
            service.messageFromNative(event);
        } else {
            Log.w(TAG,
                    "onUnknowEvent: Ignoring message because service not available: " + event);
        }
    }

}