/*
 * Copyright (C) 2011 Whisper Systems
 * Copyright (C) 2015 Open Whisper Systems
 *
 * 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, see <http://www.gnu.org/licenses/>.
 */

package org.thoughtcrime.redphone;

import android.app.Activity;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.DialogInterface;
import android.content.DialogInterface.OnClickListener;
import android.content.Intent;
import android.content.IntentFilter;
import android.content.res.Configuration;
import android.media.AudioManager;
import android.os.Build;
import android.os.Bundle;
import android.support.annotation.NonNull;
import android.support.v7.app.AlertDialog;
import android.util.Log;
import android.view.Window;
import android.view.WindowManager;

import org.thoughtcrime.redphone.ui.CallControls;
import org.thoughtcrime.redphone.ui.CallScreen;
import org.thoughtcrime.redphone.util.AudioUtils;
import org.thoughtcrime.securesms.R;
import org.thoughtcrime.securesms.events.RedPhoneEvent;
import org.thoughtcrime.securesms.recipients.Recipient;
import org.thoughtcrime.securesms.util.TextSecurePreferences;

import de.greenrobot.event.EventBus;

/**
 * The main UI class for RedPhone.  Most of the heavy lifting is
 * done by RedPhoneService, so this activity is mostly responsible
 * for receiving events about the state of ongoing calls and displaying
 * the appropriate UI components.
 *
 * @author Moxie Marlinspike
 *
 */
public class RedPhone extends Activity {

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

  private static final int STANDARD_DELAY_FINISH    = 1000;
  public  static final int BUSY_SIGNAL_DELAY_FINISH = 5500;

  private CallScreen        callScreen;
  private BroadcastReceiver bluetoothStateReceiver;

  @Override
  public void onCreate(Bundle savedInstanceState) {
    getWindow().addFlags(WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED);
    super.onCreate(savedInstanceState);

    requestWindowFeature(Window.FEATURE_NO_TITLE);
    setContentView(R.layout.redphone);

    setVolumeControlStream(AudioManager.STREAM_VOICE_CALL);

    initializeResources();
  }


  @Override
  public void onResume() {
    super.onResume();

    initializeScreenshotSecurity();
    EventBus.getDefault().registerSticky(this);
    registerBluetoothReceiver();
  }


  @Override
  public void onPause() {
    super.onPause();

    EventBus.getDefault().unregister(this);
    unregisterReceiver(bluetoothStateReceiver);
  }

  @Override
  public void onConfigurationChanged(Configuration newConfiguration) {
    super.onConfigurationChanged(newConfiguration);
  }

  private void initializeScreenshotSecurity() {
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.ICE_CREAM_SANDWICH &&
        TextSecurePreferences.isScreenSecurityEnabled(this))
    {
      getWindow().addFlags(WindowManager.LayoutParams.FLAG_SECURE);
    } else {
      getWindow().clearFlags(WindowManager.LayoutParams.FLAG_SECURE);
    }
  }

  private void initializeResources() {
    callScreen = (CallScreen)findViewById(R.id.callScreen);
    callScreen.setHangupButtonListener(new HangupButtonListener());
    callScreen.setIncomingCallActionListener(new IncomingCallActionListener());
    callScreen.setMuteButtonListener(new MuteButtonListener());
    callScreen.setAudioButtonListener(new AudioButtonListener());
  }

  private void handleSetMute(boolean enabled) {
    Intent intent = new Intent(this, RedPhoneService.class);
    intent.setAction(RedPhoneService.ACTION_SET_MUTE);
    intent.putExtra(RedPhoneService.EXTRA_MUTE, enabled);
    startService(intent);
  }

  private void handleAnswerCall() {
    RedPhoneEvent event = EventBus.getDefault().getStickyEvent(RedPhoneEvent.class);

    if (event != null) {
      callScreen.setActiveCall(event.getRecipient(), getString(org.thoughtcrime.securesms.R.string.RedPhone_answering));

      Intent intent = new Intent(this, RedPhoneService.class);
      intent.setAction(RedPhoneService.ACTION_ANSWER_CALL);
      startService(intent);
    }
  }

  private void handleDenyCall() {
    RedPhoneEvent event = EventBus.getDefault().getStickyEvent(RedPhoneEvent.class);

    if (event != null) {
      Intent intent = new Intent(this, RedPhoneService.class);
      intent.setAction(RedPhoneService.ACTION_DENY_CALL);
      startService(intent);

      callScreen.setActiveCall(event.getRecipient(), getString(org.thoughtcrime.securesms.R.string.RedPhone_ending_call));
      delayedFinish();
    }
  }

  private void handleIncomingCall(@NonNull RedPhoneEvent event) {
    callScreen.setIncomingCall(event.getRecipient());
  }

  private void handleOutgoingCall(@NonNull RedPhoneEvent event) {
    callScreen.setActiveCall(event.getRecipient(), getString(org.thoughtcrime.securesms.R.string.RedPhone_dialing));
  }

  private void handleTerminate(@NonNull Recipient recipient /*, int terminationType */) {
    Log.w(TAG, "handleTerminate called");
    Log.w(TAG, "Termination Stack:", new Exception());

    callScreen.setActiveCall(recipient, getString(R.string.RedPhone_ending_call));
    EventBus.getDefault().removeStickyEvent(RedPhoneEvent.class);

    delayedFinish();
  }

  private void handleCallRinging(@NonNull RedPhoneEvent event) {
    callScreen.setActiveCall(event.getRecipient(), getString(R.string.RedPhone_ringing));
  }

  private void handleCallBusy(@NonNull RedPhoneEvent event) {
    callScreen.setActiveCall(event.getRecipient(), getString(R.string.RedPhone_busy));

    delayedFinish(BUSY_SIGNAL_DELAY_FINISH);
  }

  private void handleCallConnected(@NonNull RedPhoneEvent event) {
    getWindow().addFlags(WindowManager.LayoutParams.FLAG_IGNORE_CHEEK_PRESSES);
    callScreen.setActiveCall(event.getRecipient(),
                             getString(R.string.RedPhone_connected),
                             event.getExtra());
  }

  private void handleConnectingToInitiator(@NonNull RedPhoneEvent event) {
    callScreen.setActiveCall(event.getRecipient(), getString(R.string.RedPhone_connecting));
  }

  private void handleHandshakeFailed(@NonNull RedPhoneEvent event) {
    callScreen.setActiveCall(event.getRecipient(), getString(R.string.RedPhone_handshake_failed));
    delayedFinish();
  }

  private void handleRecipientUnavailable(@NonNull RedPhoneEvent event) {
    callScreen.setActiveCall(event.getRecipient(), getString(R.string.RedPhone_recipient_unavailable));
    delayedFinish();
  }

  private void handlePerformingHandshake(@NonNull RedPhoneEvent event) {
    callScreen.setActiveCall(event.getRecipient(), getString(R.string.RedPhone_performing_handshake));
  }

  private void handleServerFailure(@NonNull RedPhoneEvent event) {
    callScreen.setActiveCall(event.getRecipient(), getString(R.string.RedPhone_network_failed));
    delayedFinish();
  }

  private void handleClientFailure(final @NonNull RedPhoneEvent event) {
    callScreen.setActiveCall(event.getRecipient(), getString(R.string.RedPhone_client_failed));
    if( event.getExtra() != null && !isFinishing() ) {
      AlertDialog.Builder ad = new AlertDialog.Builder(this);
      ad.setTitle(R.string.RedPhone_fatal_error);
      ad.setMessage(event.getExtra());
      ad.setCancelable(false);
      ad.setPositiveButton(android.R.string.ok, new OnClickListener() {
        public void onClick(DialogInterface dialog, int arg) {
          RedPhone.this.handleTerminate(event.getRecipient());
        }
      });
      ad.show();
    }
  }

  private void handleLoginFailed(@NonNull RedPhoneEvent event) {
    callScreen.setActiveCall(event.getRecipient(), getString(R.string.RedPhone_login_failed));
    delayedFinish();
  }

  private void handleServerMessage(final @NonNull RedPhoneEvent event) {
    if( isFinishing() ) return; //we're already shutting down, this might crash
    AlertDialog.Builder ad = new AlertDialog.Builder(this);
    ad.setTitle(R.string.RedPhone_message_from_the_server);
    ad.setMessage(event.getExtra());
    ad.setCancelable(false);
    ad.setPositiveButton(android.R.string.ok, new OnClickListener() {
      public void onClick(DialogInterface dialog, int arg) {
        RedPhone.this.handleTerminate(event.getRecipient());
      }
    });
    ad.show();
  }

  private void handleNoSuchUser(final @NonNull RedPhoneEvent event) {
    if (isFinishing()) return; // XXX Stuart added this check above, not sure why, so I'm repeating in ignorance. - moxie
    AlertDialog.Builder dialog = new AlertDialog.Builder(this);
    dialog.setTitle(R.string.RedPhone_number_not_registered);
    dialog.setIconAttribute(R.attr.dialog_alert_icon);
    dialog.setMessage(R.string.RedPhone_the_number_you_dialed_does_not_support_secure_voice);
    dialog.setCancelable(true);
    dialog.setPositiveButton(R.string.RedPhone_got_it, new OnClickListener() {
      @Override
      public void onClick(DialogInterface dialog, int which) {
        RedPhone.this.handleTerminate(event.getRecipient());
      }
    });
    dialog.setOnCancelListener(new DialogInterface.OnCancelListener() {
      @Override
      public void onCancel(DialogInterface dialog) {
        RedPhone.this.handleTerminate(event.getRecipient());
      }
    });
    dialog.show();
  }

  private void delayedFinish() {
    delayedFinish(STANDARD_DELAY_FINISH);
  }

  private void delayedFinish(int delayMillis) {
    callScreen.postDelayed(new Runnable() {
      public void run() {
        RedPhone.this.finish();
      }
    }, delayMillis);
  }

  @SuppressWarnings("unused")
  public void onEventMainThread(final RedPhoneEvent event) {
    Log.w(TAG, "Got message from service: " + event.getType());

    switch (event.getType()) {
      case CALL_CONNECTED:          handleCallConnected(event);            break;
      case SERVER_FAILURE:          handleServerFailure(event);            break;
      case PERFORMING_HANDSHAKE:    handlePerformingHandshake(event);      break;
      case HANDSHAKE_FAILED:        handleHandshakeFailed(event);          break;
      case CONNECTING_TO_INITIATOR: handleConnectingToInitiator(event);    break;
      case CALL_RINGING:            handleCallRinging(event);              break;
      case CALL_DISCONNECTED:       handleTerminate(event.getRecipient()); break;
      case SERVER_MESSAGE:          handleServerMessage(event);            break;
      case NO_SUCH_USER:            handleNoSuchUser(event);               break;
      case RECIPIENT_UNAVAILABLE:   handleRecipientUnavailable(event);     break;
      case INCOMING_CALL:           handleIncomingCall(event);             break;
      case OUTGOING_CALL:           handleOutgoingCall(event);             break;
      case CALL_BUSY:               handleCallBusy(event);                 break;
      case LOGIN_FAILED:            handleLoginFailed(event);              break;
      case CLIENT_FAILURE:			    handleClientFailure(event);            break;
    }
  }

  private class HangupButtonListener implements CallControls.HangupButtonListener {
    public void onClick() {
      Log.w(TAG, "Hangup pressed, handling termination now...");
      Intent intent = new Intent(RedPhone.this, RedPhoneService.class);
      intent.setAction(RedPhoneService.ACTION_HANGUP_CALL);
      startService(intent);

      RedPhoneEvent event = EventBus.getDefault().getStickyEvent(RedPhoneEvent.class);

      if (event != null) {
        RedPhone.this.handleTerminate(event.getRecipient());
      }
    }
  }

  private class MuteButtonListener implements CallControls.MuteButtonListener {
    @Override
    public void onToggle(boolean isMuted) {
      RedPhone.this.handleSetMute(isMuted);
    }
  }

  private void registerBluetoothReceiver() {
    IntentFilter filter = new IntentFilter();
    filter.addAction(AudioUtils.getScoUpdateAction());
    bluetoothStateReceiver = new BroadcastReceiver() {
      @Override
      public void onReceive(Context context, Intent intent) {
        callScreen.notifyBluetoothChange();
      }
    };

    registerReceiver(bluetoothStateReceiver, filter);
    callScreen.notifyBluetoothChange();
  }

  private class AudioButtonListener implements CallControls.AudioButtonListener {
    @Override
    public void onAudioChange(AudioUtils.AudioMode mode) {
      switch(mode) {
        case DEFAULT:
          AudioUtils.enableDefaultRouting(RedPhone.this);
          break;
        case SPEAKER:
          AudioUtils.enableSpeakerphoneRouting(RedPhone.this);
          break;
        case HEADSET:
          AudioUtils.enableBluetoothRouting(RedPhone.this);
          break;
        default:
          throw new IllegalStateException("Audio mode " + mode + " is not supported.");
      }
    }
  }

  private class IncomingCallActionListener implements CallControls.IncomingCallActionListener {
    @Override
    public void onAcceptClick() {
      RedPhone.this.handleAnswerCall();
    }

    @Override
    public void onDenyClick() {
      RedPhone.this.handleDenyCall();
    }
  }

}