/*
 * Copyright (C) 2014 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.
 */

package com.android.tv.settings.connectivity.setup;

import android.animation.Animator;
import android.animation.AnimatorInflater;
import android.animation.ObjectAnimator;
import android.app.Fragment;
import android.app.FragmentManager;
import android.app.FragmentTransaction;
import android.content.Context;
import android.content.Intent;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;
import android.net.wifi.ScanResult;
import android.net.wifi.WifiConfiguration;
import android.net.wifi.WifiInfo;
import android.net.wifi.WifiManager;
import android.os.Bundle;
import android.os.HandlerThread;
import android.os.Process;
import android.text.TextUtils;
import android.util.Pair;
import android.view.accessibility.AccessibilityEvent;

import com.android.settingslib.wifi.WifiTracker;
import com.android.tv.settings.R;
import com.android.tv.settings.connectivity.AdvancedWifiOptionsFlow;
import com.android.tv.settings.connectivity.ConnectToWifiFragment;
import com.android.tv.settings.connectivity.FormPageDisplayer;
import com.android.tv.settings.connectivity.TimedMessageWizardFragment;
import com.android.tv.settings.connectivity.WifiConfigHelper;
import com.android.tv.settings.connectivity.WifiFormPageType;
import com.android.tv.settings.connectivity.WifiMultiPagedFormActivity;
import com.android.tv.settings.connectivity.WifiSecurity;
import com.android.tv.settings.connectivity.WpsConnectionActivity;
import com.android.tv.settings.connectivity.setup.SelectFromListWizardFragment.ListItem;
import com.android.tv.settings.form.FormPage;
import com.android.tv.settings.form.FormPageResultListener;
import com.android.tv.settings.util.ThemeHelper;
import com.android.tv.settings.util.TransitionUtils;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;

/**
 * Wi-Fi settings during initial setup for a large no-touch device
 */
public class WifiSetupActivity extends WifiMultiPagedFormActivity
        implements ConnectToWifiFragment.Listener, TimedMessageWizardFragment.Listener {

    private static final String TAG = "WifiSetupActivity";
    private static final int NETWORK_REFRESH_BUFFER_DURATION = 5000;

    private static final String EXTRA_SHOW_SUMMARY = "extra_show_summary";
    private static final String EXTRA_SHOW_SKIP_NETWORK = "extra_show_skip_network";
    private static final String EXTRA_SHOW_WPS_AT_TOP = "extra_show_wps_at_top";
    private static final String EXTRA_MOVING_FORWARD = "movingForward";
    // If you change this constant, make sure to change the constant in setup wizard
    private static final int RESULT_NETWORK_SKIPPED = 3;

    private boolean mResultOk = false;
    private boolean mShowFirstFragmentBackwards;
    private boolean mShowSkipNetwork;
    private boolean mShowWpsAtTop;
    private AdvancedWifiOptionsFlow mAdvancedWifiOptionsFlow;
    private WifiTracker mWifiTracker;
    private HandlerThread mBgThread;

    private WifiConfiguration mConfiguration;
    private String mConnectedNetwork;
    private WifiSecurity mWifiSecurity;
    private FormPageDisplayer.UserActivityListener mUserActivityListener;
    private FormPage mChooseNetworkPage;
    private FormPage mSsidPage;
    private FormPage mSecurityPage;
    private FormPage mPasswordPage;
    private SelectFromListWizardFragment mNetworkListFragment;
    private FormPage mConnectPage;
    private FormPage mSuccessPage;
    private long mNextNetworkRefreshTime;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        mConfiguration = new WifiConfiguration();

        WifiTracker.WifiListener wifiListener = new WifiTracker.WifiListener() {
            @Override
            public void onWifiStateChanged(int state) {}

            @Override
            public void onConnectedChanged() {}

            @Override
            public void onAccessPointsChanged() {
                long currentTime = System.currentTimeMillis();
                if (mNetworkListFragment != null && currentTime >= mNextNetworkRefreshTime) {
                    mNetworkListFragment.update(WifiFormPageType.CHOOSE_NETWORK.getChoices(
                            WifiSetupActivity.this, getNetworks()));
                    mNextNetworkRefreshTime = currentTime + NETWORK_REFRESH_BUFFER_DURATION;
                }
            }
        };
        mBgThread = new HandlerThread(TAG, Process.THREAD_PRIORITY_BACKGROUND);
        mBgThread.start();
        mWifiTracker = new WifiTracker(this, wifiListener, mBgThread.getLooper(), true, true);
        mNextNetworkRefreshTime = System.currentTimeMillis() + NETWORK_REFRESH_BUFFER_DURATION;

        mUserActivityListener = new FormPageDisplayer.UserActivityListener() {
            @Override
            public void onUserActivity() {
                mNextNetworkRefreshTime =
                        System.currentTimeMillis() + NETWORK_REFRESH_BUFFER_DURATION;
            }
        };

        boolean showSummary = getIntent().getBooleanExtra(EXTRA_SHOW_SUMMARY, false);
        mShowSkipNetwork = getIntent().getBooleanExtra(EXTRA_SHOW_SKIP_NETWORK, false);
        mShowWpsAtTop = getIntent().getBooleanExtra(EXTRA_SHOW_WPS_AT_TOP, false);
        // If we are not moving forwards during the setup flow, we need to show the first fragment
        // with the reverse animation.
        mShowFirstFragmentBackwards = !getIntent().getBooleanExtra(EXTRA_MOVING_FORWARD, true);

        if (showSummary) {
            addSummaryPage();
        } else {
            addPage(WifiFormPageType.CHOOSE_NETWORK);
        }

        super.onCreate(savedInstanceState);

        // fade in
        ObjectAnimator animator = TransitionUtils.createActivityFadeInAnimator(getResources(),
                true);
        animator.setTarget(getContentView());
        animator.start();
    }

    @Override
    public void onResume() {
        super.onResume();
        mWifiTracker.startTracking();
    }

    @Override
    public void onPause() {
        super.onPause();
        mWifiTracker.stopTracking();
    }

    @Override
    public void finish() {
        Animator animator;

        // Choose finish animation based on whether we are in Setup or Settings and really
        // finish this activity when the animation is complete.
        if (ThemeHelper.fromSetupWizard(getIntent())) {
            animator = mResultOk
                    ? AnimatorInflater.loadAnimator(this, R.anim.setup_fragment_open_out)
                    : AnimatorInflater.loadAnimator(this, R.anim.setup_fragment_close_out);
        } else {
            animator = TransitionUtils.createActivityFadeOutAnimator(getResources(), true);
        }

        animator.setTarget(getContentView());
        animator.addListener(new Animator.AnimatorListener() {

            @Override
            public void onAnimationStart(Animator animation) {
            }

            @Override
            public void onAnimationRepeat(Animator animation) {
            }

            @Override
            public void onAnimationEnd(Animator animation) {
                doFinish();
            }

            @Override
            public void onAnimationCancel(Animator animation) {
            }
        });
        animator.start();
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        mBgThread.quit();
    }

    @Override
    public void onConnectToWifiCompleted(int reason) {
        Bundle result = new Bundle();
        result.putString(FormPage.DATA_KEY_SUMMARY_STRING, Integer.toString(reason));
        onBundlePageResult(mConnectPage, result);
    }

    @Override
    public void onTimedMessageCompleted() {
        Bundle result = new Bundle();
        result.putString(FormPage.DATA_KEY_SUMMARY_STRING, "");
        onBundlePageResult(mSuccessPage, result);
    }

    @Override
    public void addPage(WifiFormPageType formPageType) {
        for (int i = mFormPages.size() - 1; i >= 0; i--) {
            if (getFormPageType(mFormPages.get (i)) == formPageType) {
                for (int j = mFormPages.size() - 1; j >= i; j--) {
                    mFormPages.remove(j);
                }
                break;
            }
        }
        addPage(formPageType.create());
    }

    @Override
    protected boolean onPageComplete(WifiFormPageType formPageType, FormPage formPage) {

        switch (formPageType) {
            case KNOWN_NETWORK:
                if (choiceChosen(formPage, R.string.wifi_connect)) {
                    addStartPage();
                } else if (choiceChosen(formPage, R.string.wifi_forget_network)) {
                    ((WifiManager) getSystemService(Context.WIFI_SERVICE)).forget(
                            mConfiguration.networkId, null);
                    addPage(WifiFormPageType.CHOOSE_NETWORK);
                }
                break;
            case CHOOSE_NETWORK:
                if (choiceChosen(formPage, R.string.skip_network)) {
                    WifiConfigHelper.forgetWifiNetwork(this);
                    setResult(RESULT_NETWORK_SKIPPED);
                } else {
                    mWifiTracker.pauseScanning();
                    mNetworkListFragment = null;
                    mChooseNetworkPage = formPage;
                    addPageBasedOnNetworkChoice(mChooseNetworkPage);
                }
                break;
            case ENTER_SSID:
                mSsidPage = formPage;
                String ssid = formPage.getDataSummary();
                if (mPasswordPage != null
                        && !TextUtils.equals(mConfiguration.getPrintableSsid(), ssid)) {
                    mPasswordPage.clearData();
                }
                WifiConfigHelper.setConfigSsid(mConfiguration, ssid);
                addPage(WifiFormPageType.CHOOSE_SECURITY);
                break;
            case CHOOSE_SECURITY:
                mSecurityPage = formPage;
                if (choiceChosen(formPage, R.string.wifi_security_type_none)) {
                    mWifiSecurity = WifiSecurity.NONE;
                } else if (choiceChosen(formPage, R.string.wifi_security_type_wep)) {
                    mWifiSecurity = WifiSecurity.WEP;
                } else if (choiceChosen(formPage, R.string.wifi_security_type_wpa)) {
                    mWifiSecurity = WifiSecurity.PSK;
                } else if (choiceChosen(formPage, R.string.wifi_security_type_eap)) {
                    mWifiSecurity = WifiSecurity.EAP;
                }
                WifiConfigHelper.setConfigKeyManagementBySecurity(mConfiguration, mWifiSecurity);
                if (mWifiSecurity == WifiSecurity.NONE) {
                    optionsOrConnect();
                } else {
                    addPage(WifiFormPageType.ENTER_PASSWORD);
                }
                break;
            case ENTER_PASSWORD:
                mPasswordPage = formPage;
                String password = formPage.getDataSummary();
                setWifiConfigurationPassword(mConfiguration, mWifiSecurity, password);
                optionsOrConnect();
                break;
            case CONNECT:
                switch (Integer.valueOf(formPage.getDataSummary())) {
                    case ConnectToWifiFragment.RESULT_REJECTED_BY_AP:
                        addPage(WifiFormPageType.CONNECT_REJECTED_BY_AP);
                        break;
                    case ConnectToWifiFragment.RESULT_UNKNOWN_ERROR:
                        addPage(WifiFormPageType.CONNECT_FAILED);
                        break;
                    case ConnectToWifiFragment.RESULT_TIMEOUT:
                        addPage(WifiFormPageType.CONNECT_TIMEOUT);
                        break;
                    case ConnectToWifiFragment.RESULT_BAD_AUTHENTICATION:
                        WifiConfigHelper.forgetConfiguration(this, mConfiguration);
                        addPage(WifiFormPageType.CONNECT_AUTHENTICATION_FAILURE);
                        break;
                    case ConnectToWifiFragment.RESULT_SUCCESS:
                        WifiConfigHelper.saveConfiguration(this, mConfiguration);
                        addPage(WifiFormPageType.SUCCESS);
                        break;
                    default:
                        break;
                }
                break;
            case CONNECT_TIMEOUT:
                mAdvancedWifiOptionsFlow = new AdvancedWifiOptionsFlow(this, this, true, null);
                // fall through
            case CONNECT_REJECTED_BY_AP:
                if (choiceChosen(formPage, R.string.wifi_action_try_again)) {
                    optionsOrConnect();
                } else {
                    mSsidPage = null;
                    mSecurityPage = null;
                    mPasswordPage = null;
                    addPage(WifiFormPageType.CHOOSE_NETWORK);
                }
                break;
            case CONNECT_FAILED:
                // fall through
            case CONNECT_AUTHENTICATION_FAILURE:
                if (choiceChosen(formPage, R.string.wifi_action_try_again)) {
                    addPageBasedOnNetworkChoice(mChooseNetworkPage);
                } else {
                    mSsidPage = null;
                    mSecurityPage = null;
                    mPasswordPage = null;
                    addPage(WifiFormPageType.CHOOSE_NETWORK);
                }
                break;
            case SUMMARY_CONNECTED_WIFI:
                if (choiceChosen(formPage, R.string.wifi_action_dont_change_network)) {
                    setResultOk();
                    finish();
                } else if (choiceChosen(formPage, R.string.wifi_action_change_network)) {
                    addPage(WifiFormPageType.CHOOSE_NETWORK);
                }
                break;
            case SUMMARY_CONNECTED_NON_WIFI:
                setResultOk();
                finish();
                break;
            case SUMMARY_NOT_CONNECTED:
                addPage(WifiFormPageType.CHOOSE_NETWORK);
                break;
            case SUCCESS:
                setResultOk();
                break;
            case WPS:
                setResultOk();
                break;
            default:
                if (mAdvancedWifiOptionsFlow != null) {
                    switch (mAdvancedWifiOptionsFlow.handlePageComplete(formPageType, formPage)) {
                        case AdvancedWifiOptionsFlow.RESULT_ALL_PAGES_COMPLETE:
                            connect();
                            break;
                        case AdvancedWifiOptionsFlow.RESULT_UNKNOWN_PAGE:
                        case AdvancedWifiOptionsFlow.RESULT_PAGE_HANDLED:
                        default:
                            break;
                    }
                }
                break;
        }
        return true;
    }

    @Override
    protected void displayPage(FormPage formPage, FormPageResultListener listener,
            boolean forward) {
        WifiFormPageType formPageType = getFormPageType(formPage);

        if (mShowFirstFragmentBackwards) {
            // We entered this activity by moving backwards in setup, so set the forward boolean
            // to false in order to show the first fragment with backwards animation.
            forward = false;

            // Reset the flag to false so that following fragments are handled normally.
            mShowFirstFragmentBackwards = false;
        }

        if (formPageType == WifiFormPageType.CONNECT) {
            mConnectPage = formPage;
            Fragment fragment = ConnectToWifiFragment.newInstance(
                    getString(formPageType.getTitleResourceId(), mConfiguration.getPrintableSsid()),
                    true, mConfiguration);
            displayFragment(fragment, forward);
        } else if (formPageType == WifiFormPageType.SUCCESS) {
            mSuccessPage = formPage;
            Fragment fragment = TimedMessageWizardFragment.newInstance(
                    getString(formPageType.getTitleResourceId()));
            displayFragment(fragment, forward);
        } else if (formPageType == WifiFormPageType.WPS) {
            displayFragment(MessageWizardFragment.newInstance("", true), forward);
        } else {
            Fragment fragment = displayPage(formPageType, mConfiguration.getPrintableSsid(),
                    formPageType == WifiFormPageType.SUMMARY_CONNECTED_WIFI ? mConnectedNetwork
                            : null,
                    formPageType == WifiFormPageType.CHOOSE_NETWORK ? getNetworks() : null,
                    getLastPage(formPageType),
                    formPageType == WifiFormPageType.CHOOSE_NETWORK ? mUserActivityListener : null,
                    formPageType != WifiFormPageType.SUCCESS, formPage, listener, forward,
                            (mAdvancedWifiOptionsFlow != null) ? mAdvancedWifiOptionsFlow
                            .isEmptyTextAllowed(formPageType) : false);
            if (formPageType == WifiFormPageType.CHOOSE_NETWORK) {
                mNetworkListFragment = (SelectFromListWizardFragment) fragment;
                mWifiTracker.resumeScanning();
            }
        }
        if (ThemeHelper.fromSetupWizard(getIntent())) {
            updateTitle(formPageType);
        }
    }

    @Override
    protected void undisplayCurrentPage() {
        mWifiTracker.pauseScanning();

        FragmentManager fragMan = getFragmentManager();
        Fragment target = fragMan.findFragmentById(R.id.content);
        FragmentTransaction transaction = fragMan.beginTransaction();
        transaction.remove(target);
        transaction.setTransition(FragmentTransaction.TRANSIT_FRAGMENT_CLOSE);
        transaction.commit();
    }

    private void doFinish() {
        super.finish();
    }

    private void connect() {
        if (!WifiConfigHelper.isNetworkSaved(mConfiguration) &&
            mAdvancedWifiOptionsFlow != null) {
            mAdvancedWifiOptionsFlow.updateConfiguration(mConfiguration);
        }
        addPage(WifiFormPageType.CONNECT);
    }

    private void optionsOrConnect() {
        if (mAdvancedWifiOptionsFlow != null) {
            addPage(mAdvancedWifiOptionsFlow.getInitialPage());
        } else {
            connect();
        }
    }

    private FormPage getLastPage(WifiFormPageType formPageType) {
        switch (formPageType) {
            case CHOOSE_NETWORK:
                return mChooseNetworkPage;
            case CHOOSE_SECURITY:
                return mSecurityPage;
            case ENTER_PASSWORD:
                return mPasswordPage;
            case ENTER_SSID:
                return mSsidPage;
            default:
                return (mAdvancedWifiOptionsFlow != null) ? mAdvancedWifiOptionsFlow
                        .getPreviousPage(formPageType)
                        : null;
        }
    }

    private ArrayList<ListItem> getNetworks() {
        ArrayList<SelectFromListWizardFragment.ListItem> listItems = new ArrayList<>();
        final List<ScanResult> results = mWifiTracker.getManager().getScanResults();
        final HashMap<Pair<String, WifiSecurity>, ScanResult> consolidatedScanResults =
                new HashMap<>();
        for (ScanResult result : results) {
            if (TextUtils.isEmpty(result.SSID)) {
                continue;
            }

            Pair<String, WifiSecurity> key =
                    new Pair<>(result.SSID, WifiSecurity.getSecurity(result));
            ScanResult existing = consolidatedScanResults.get(key);
            if (existing == null || existing.level < result.level) {
                consolidatedScanResults.put(key, result);
            }
        }
        for (ScanResult result : consolidatedScanResults.values()) {
            listItems.add(new SelectFromListWizardFragment.ListItem(result));
        }

        int wpsPinnedPos = mShowWpsAtTop ? SelectFromListWizardFragment.PinnedListItem.FIRST
                                         : SelectFromListWizardFragment.PinnedListItem.LAST;

        SelectFromListWizardFragment.PinnedListItem wpsItem =
                new SelectFromListWizardFragment.PinnedListItem(
                        getString(R.string.wps_network), R.drawable.setup_wps, wpsPinnedPos, 0);

        listItems.add(wpsItem);

        if (mShowSkipNetwork) {
            listItems.add(new SelectFromListWizardFragment.PinnedListItem(
                    getString(R.string.skip_network), R.drawable.ic_arrow_forward,
                    SelectFromListWizardFragment.PinnedListItem.LAST, 1));
        }

        return listItems;
    }

    private void addPageBasedOnNetworkChoice(FormPage chooseNetworkPage) {
        if (choiceChosen(chooseNetworkPage, R.string.other_network)) {
            mConfiguration.hiddenSSID = true;
            addPage(WifiFormPageType.ENTER_SSID);
        } else if (choiceChosen(chooseNetworkPage, R.string.wps_network)) {
            addPage(WifiFormPageType.WPS, new Intent(this, WpsConnectionActivity.class)
                    .putExtras(getIntent().getExtras()));
        } else {
            ScanResult scanResult = getListItem(chooseNetworkPage).getScanResult();

            // If we are entering password for an AP that is different from the previously saved AP,
            // clear out the saved password.
            if (mPasswordPage != null
                    && (mConfiguration == null
                               || !scanResult.SSID.equals(mConfiguration.getPrintableSsid()))) {
                mPasswordPage.clearData();
            }

            mConfiguration = WifiConfigHelper.getConfiguration(this, scanResult.SSID,
                    WifiSecurity.getSecurity(scanResult));
            mWifiSecurity = WifiSecurity.getSecurity(scanResult);

            if (WifiConfigHelper.isNetworkSaved(mConfiguration)) {
                addPage(WifiFormPageType.KNOWN_NETWORK);
            } else {
                addStartPage();
            }
        }
    }

    private void addStartPage() {
        if ((mWifiSecurity == WifiSecurity.WEP && TextUtils.isEmpty(mConfiguration.wepKeys[0]))
                || (!mWifiSecurity.isOpen() && TextUtils.isEmpty(mConfiguration.preSharedKey))) {
            addPage(WifiFormPageType.ENTER_PASSWORD);
        } else {
            connect();
        }
    }

    private void addSummaryPage() {
        ConnectivityManager connectivityManager = (ConnectivityManager) getSystemService(
                Context.CONNECTIVITY_SERVICE);
        NetworkInfo currentConnection = connectivityManager.getActiveNetworkInfo();
        boolean isConnected = (currentConnection != null) && currentConnection.isConnected();
        if (isConnected) {
            if (currentConnection.getType() == ConnectivityManager.TYPE_WIFI) {
                WifiInfo currentWifiConnection = mWifiTracker.getManager().getConnectionInfo();
                mConnectedNetwork = WifiInfo.removeDoubleQuotes(
                        currentWifiConnection.getSSID());
                if (mConnectedNetwork == null) {
                    mConnectedNetwork = getString(R.string.wifi_summary_unknown_network);
                }
                addPage(WifiFormPageType.SUMMARY_CONNECTED_WIFI);
            } else {
                addPage(WifiFormPageType.SUMMARY_CONNECTED_NON_WIFI);
            }
        } else {
            addPage(WifiFormPageType.SUMMARY_NOT_CONNECTED);
        }
    }

    private void updateTitle(WifiFormPageType pageType) {
        switch (pageType) {
            // Fall through for all pageTypes that require the SSID of the network for
            // the title.
            case ADVANCED_OPTIONS:
            case CONNECT:
            case CONNECT_FAILED:
            case CONNECT_TIMEOUT:
            case KNOWN_NETWORK:
            case SAVE:
            case SAVE_FAILED:
                setTitle(getResources().getString(pageType.getTitleResourceId(),
                        mConfiguration.getPrintableSsid()));
                break;
            case WPS:
                // Delegate title to the WPSConnectionActivity. Use blank string to prevent
                // talkback from announcing a misplaced title.
                setTitle("");
                return;
            case ENTER_PASSWORD:
                // IME screen; Let the IME handle announcements.
                setTitle("");
                return;
            case ENTER_SSID:
                // IME screen; Let the IME handle announcements.
                setTitle("");
                return;
            default:
                setTitle(getResources().getString(pageType.getTitleResourceId()));
                break;
        }
        getWindow().getDecorView()
                .sendAccessibilityEvent(AccessibilityEvent.TYPE_WINDOW_STATE_CHANGED);
    }

    private void setResultOk() {
        setResult(RESULT_OK);
        mResultOk = true;
    }
}