/*
 * Copyright (C) 2018 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.server.wifi;

import static com.android.server.wifi.ConnectToNetworkNotificationBuilder.ACTION_CONNECT_TO_NETWORK;
import static com.android.server.wifi.ConnectToNetworkNotificationBuilder.ACTION_PICK_WIFI_NETWORK;
import static com.android.server.wifi.ConnectToNetworkNotificationBuilder.ACTION_PICK_WIFI_NETWORK_AFTER_CONNECT_FAILURE;
import static com.android.server.wifi.ConnectToNetworkNotificationBuilder.ACTION_USER_DISMISSED_NOTIFICATION;
import static com.android.server.wifi.ConnectToNetworkNotificationBuilder.AVAILABLE_NETWORK_NOTIFIER_TAG;

import android.annotation.IntDef;
import android.annotation.NonNull;
import android.app.Notification;
import android.app.NotificationManager;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.database.ContentObserver;
import android.net.wifi.ScanResult;
import android.net.wifi.WifiConfiguration;
import android.net.wifi.WifiManager;
import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.os.Messenger;
import android.os.Process;
import android.os.UserHandle;
import android.os.UserManager;
import android.provider.Settings;
import android.text.TextUtils;
import android.util.ArraySet;
import android.util.Log;

import com.android.internal.annotations.VisibleForTesting;
import com.android.server.wifi.nano.WifiMetricsProto.ConnectToNetworkNotificationAndActionCount;
import com.android.server.wifi.util.ScanResultUtil;

import java.io.FileDescriptor;
import java.io.PrintWriter;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.util.List;
import java.util.Set;

/**
 * Base class for all network notifiers (e.g. OpenNetworkNotifier, CarrierNetworkNotifier).
 *
 * NOTE: These API's are not thread safe and should only be used from WifiCoreThread.
 */
public class AvailableNetworkNotifier {

    /** Time in milliseconds to display the Connecting notification. */
    private static final int TIME_TO_SHOW_CONNECTING_MILLIS = 10000;

    /** Time in milliseconds to display the Connected notification. */
    private static final int TIME_TO_SHOW_CONNECTED_MILLIS = 5000;

    /** Time in milliseconds to display the Failed To Connect notification. */
    private static final int TIME_TO_SHOW_FAILED_MILLIS = 5000;

    /** The state of the notification */
    @IntDef({
            STATE_NO_NOTIFICATION,
            STATE_SHOWING_RECOMMENDATION_NOTIFICATION,
            STATE_CONNECTING_IN_NOTIFICATION,
            STATE_CONNECTED_NOTIFICATION,
            STATE_CONNECT_FAILED_NOTIFICATION
    })
    @Retention(RetentionPolicy.SOURCE)
    private @interface State {}

    /** No recommendation is made and no notifications are shown. */
    private static final int STATE_NO_NOTIFICATION = 0;
    /** The initial notification recommending a network to connect to is shown. */
    private static final int STATE_SHOWING_RECOMMENDATION_NOTIFICATION = 1;
    /** The notification of status of connecting to the recommended network is shown. */
    private static final int STATE_CONNECTING_IN_NOTIFICATION = 2;
    /** The notification that the connection to the recommended network was successful is shown. */
    private static final int STATE_CONNECTED_NOTIFICATION = 3;
    /** The notification to show that connection to the recommended network failed is shown. */
    private static final int STATE_CONNECT_FAILED_NOTIFICATION = 4;

    /** Current state of the notification. */
    @State private int mState = STATE_NO_NOTIFICATION;

    /**
     * The {@link Clock#getWallClockMillis()} must be at least this value for us
     * to show the notification again.
     */
    private long mNotificationRepeatTime;
    /**
     * When a notification is shown, we wait this amount before possibly showing it again.
     */
    private final long mNotificationRepeatDelay;
    /** Default repeat delay in seconds. */
    @VisibleForTesting
    static final int DEFAULT_REPEAT_DELAY_SEC = 900;

    /** Whether the user has set the setting to show the 'available networks' notification. */
    private boolean mSettingEnabled;
    /** Whether the screen is on or not. */
    private boolean mScreenOn;

    /** List of SSIDs blacklisted from recommendation. */
    private final Set<String> mBlacklistedSsids = new ArraySet<>();

    private final Context mContext;
    private final Handler mHandler;
    private final FrameworkFacade mFrameworkFacade;
    private final WifiMetrics mWifiMetrics;
    private final Clock mClock;
    private final WifiConfigManager mConfigManager;
    private final ClientModeImpl mClientModeImpl;
    private final Messenger mSrcMessenger;
    private final ConnectToNetworkNotificationBuilder mNotificationBuilder;

    private ScanResult mRecommendedNetwork;

    /** Tag used for logs and metrics */
    private final String mTag;
    /** Identifier of the {@link SsidSetStoreData}. */
    private final String mStoreDataIdentifier;
    /** Identifier for the settings toggle, used for registering ContentObserver */
    private final String mToggleSettingsName;

    /** System wide identifier for notification in Notification Manager */
    private final int mSystemMessageNotificationId;

    /**
     * The nominator id for this class, from
     * {@link com.android.server.wifi.nano.WifiMetricsProto.ConnectionEvent.ConnectionNominator}
     */
    private final int mNominatorId;

    public AvailableNetworkNotifier(
            String tag,
            String storeDataIdentifier,
            String toggleSettingsName,
            int notificationIdentifier,
            int nominatorId,
            Context context,
            Looper looper,
            FrameworkFacade framework,
            Clock clock,
            WifiMetrics wifiMetrics,
            WifiConfigManager wifiConfigManager,
            WifiConfigStore wifiConfigStore,
            ClientModeImpl clientModeImpl,
            ConnectToNetworkNotificationBuilder connectToNetworkNotificationBuilder) {
        mTag = tag;
        mStoreDataIdentifier = storeDataIdentifier;
        mToggleSettingsName = toggleSettingsName;
        mSystemMessageNotificationId = notificationIdentifier;
        mNominatorId = nominatorId;
        mContext = context;
        mHandler = new Handler(looper);
        mFrameworkFacade = framework;
        mWifiMetrics = wifiMetrics;
        mClock = clock;
        mConfigManager = wifiConfigManager;
        mClientModeImpl = clientModeImpl;
        mNotificationBuilder = connectToNetworkNotificationBuilder;
        mScreenOn = false;
        mSrcMessenger = new Messenger(new Handler(looper, mConnectionStateCallback));
        wifiConfigStore.registerStoreData(new SsidSetStoreData(mStoreDataIdentifier,
                new AvailableNetworkNotifierStoreData()));

        // Setting is in seconds
        mNotificationRepeatDelay = mFrameworkFacade.getIntegerSetting(context,
                Settings.Global.WIFI_NETWORKS_AVAILABLE_REPEAT_DELAY,
                DEFAULT_REPEAT_DELAY_SEC) * 1000L;
        NotificationEnabledSettingObserver settingObserver = new NotificationEnabledSettingObserver(
                mHandler);
        settingObserver.register();

        IntentFilter filter = new IntentFilter();
        filter.addAction(ACTION_USER_DISMISSED_NOTIFICATION);
        filter.addAction(ACTION_CONNECT_TO_NETWORK);
        filter.addAction(ACTION_PICK_WIFI_NETWORK);
        filter.addAction(ACTION_PICK_WIFI_NETWORK_AFTER_CONNECT_FAILURE);
        mContext.registerReceiver(
                mBroadcastReceiver, filter, null /* broadcastPermission */, mHandler);
    }

    private final BroadcastReceiver mBroadcastReceiver =
            new BroadcastReceiver() {
                @Override
                public void onReceive(Context context, Intent intent) {
                    if (!mTag.equals(intent.getExtra(AVAILABLE_NETWORK_NOTIFIER_TAG))) {
                        return;
                    }
                    switch (intent.getAction()) {
                        case ACTION_USER_DISMISSED_NOTIFICATION:
                            handleUserDismissedAction();
                            break;
                        case ACTION_CONNECT_TO_NETWORK:
                            handleConnectToNetworkAction();
                            break;
                        case ACTION_PICK_WIFI_NETWORK:
                            handleSeeAllNetworksAction();
                            break;
                        case ACTION_PICK_WIFI_NETWORK_AFTER_CONNECT_FAILURE:
                            handlePickWifiNetworkAfterConnectFailure();
                            break;
                        default:
                            Log.e(mTag, "Unknown action " + intent.getAction());
                    }
                }
            };

    private final Handler.Callback mConnectionStateCallback = (Message msg) -> {
        switch (msg.what) {
            // Success here means that an attempt to connect to the network has been initiated.
            // Successful connection updates are received via the
            // WifiConnectivityManager#handleConnectionStateChanged() callback.
            case WifiManager.CONNECT_NETWORK_SUCCEEDED:
                break;
            case WifiManager.CONNECT_NETWORK_FAILED:
                handleConnectionAttemptFailedToSend();
                break;
            default:
                Log.e("AvailableNetworkNotifier", "Unknown message " + msg.what);
        }
        return true;
    };

    /**
     * Clears the pending notification. This is called by {@link WifiConnectivityManager} on stop.
     *
     * @param resetRepeatTime resets the time delay for repeated notification if true.
     */
    public void clearPendingNotification(boolean resetRepeatTime) {
        if (resetRepeatTime) {
            mNotificationRepeatTime = 0;
        }

        if (mState != STATE_NO_NOTIFICATION) {
            getNotificationManager().cancel(mSystemMessageNotificationId);

            if (mRecommendedNetwork != null) {
                Log.d(mTag, "Notification with state="
                        + mState
                        + " was cleared for recommended network: "
                        + "\"" + mRecommendedNetwork.SSID + "\"");
            }
            mState = STATE_NO_NOTIFICATION;
            mRecommendedNetwork = null;
        }
    }

    private boolean isControllerEnabled() {
        return mSettingEnabled && !UserManager.get(mContext)
                .hasUserRestriction(UserManager.DISALLOW_CONFIG_WIFI, UserHandle.CURRENT);
    }

    /**
     * If there are available networks, attempt to post a network notification.
     *
     * @param availableNetworks Available networks to choose from and possibly show notification
     */
    public void handleScanResults(@NonNull List<ScanDetail> availableNetworks) {
        if (!isControllerEnabled()) {
            clearPendingNotification(true /* resetRepeatTime */);
            return;
        }
        if (availableNetworks.isEmpty() && mState == STATE_SHOWING_RECOMMENDATION_NOTIFICATION) {
            clearPendingNotification(false /* resetRepeatTime */);
            return;
        }

        // Not enough time has passed to show a recommendation notification again
        if (mState == STATE_NO_NOTIFICATION
                && mClock.getWallClockMillis() < mNotificationRepeatTime) {
            return;
        }

        // Do nothing when the screen is off and no notification is showing.
        if (mState == STATE_NO_NOTIFICATION && !mScreenOn) {
            return;
        }

        // Only show a new or update an existing recommendation notification.
        if (mState == STATE_NO_NOTIFICATION
                || mState == STATE_SHOWING_RECOMMENDATION_NOTIFICATION) {
            ScanResult recommendation =
                    recommendNetwork(availableNetworks);

            if (recommendation != null) {
                postInitialNotification(recommendation);
            } else {
                clearPendingNotification(false /* resetRepeatTime */);
            }
        }
    }

    /**
     * Recommends a network to connect to from a list of available networks, while ignoring the
     * SSIDs in the blacklist.
     *
     * @param networks List of networks to select from
     */
    public ScanResult recommendNetwork(@NonNull List<ScanDetail> networks) {
        ScanResult result = null;
        int highestRssi = Integer.MIN_VALUE;
        for (ScanDetail scanDetail : networks) {
            ScanResult scanResult = scanDetail.getScanResult();

            if (scanResult.level > highestRssi) {
                result = scanResult;
                highestRssi = scanResult.level;
            }
        }

        if (result != null && mBlacklistedSsids.contains(result.SSID)) {
            result = null;
        }
        return result;
    }

    /** Handles screen state changes. */
    public void handleScreenStateChanged(boolean screenOn) {
        mScreenOn = screenOn;
    }

    /**
     * Called by {@link WifiConnectivityManager} when Wi-Fi is connected. If the notification
     * was in the connecting state, update the notification to show that it has connected to the
     * recommended network.
     *
     * @param ssid The connected network's ssid
     */
    public void handleWifiConnected(String ssid) {
        removeNetworkFromBlacklist(ssid);
        if (mState != STATE_CONNECTING_IN_NOTIFICATION) {
            clearPendingNotification(true /* resetRepeatTime */);
            return;
        }

        postNotification(mNotificationBuilder.createNetworkConnectedNotification(mTag,
                mRecommendedNetwork));

        Log.d(mTag, "User connected to recommended network: "
                + "\"" + mRecommendedNetwork.SSID + "\"");
        mWifiMetrics.incrementConnectToNetworkNotification(mTag,
                ConnectToNetworkNotificationAndActionCount.NOTIFICATION_CONNECTED_TO_NETWORK);
        mState = STATE_CONNECTED_NOTIFICATION;
        mHandler.postDelayed(
                () -> {
                    if (mState == STATE_CONNECTED_NOTIFICATION) {
                        clearPendingNotification(true /* resetRepeatTime */);
                    }
                },
                TIME_TO_SHOW_CONNECTED_MILLIS);
    }

    /**
     * Handles when a Wi-Fi connection attempt failed.
     */
    public void handleConnectionFailure() {
        if (mState != STATE_CONNECTING_IN_NOTIFICATION) {
            return;
        }
        postNotification(mNotificationBuilder.createNetworkFailedNotification(mTag));

        Log.d(mTag, "User failed to connect to recommended network: "
                + "\"" + mRecommendedNetwork.SSID + "\"");
        mWifiMetrics.incrementConnectToNetworkNotification(mTag,
                ConnectToNetworkNotificationAndActionCount.NOTIFICATION_FAILED_TO_CONNECT);
        mState = STATE_CONNECT_FAILED_NOTIFICATION;
        mHandler.postDelayed(
                () -> {
                    if (mState == STATE_CONNECT_FAILED_NOTIFICATION) {
                        clearPendingNotification(false /* resetRepeatTime */);
                    }
                },
                TIME_TO_SHOW_FAILED_MILLIS);
    }

    private NotificationManager getNotificationManager() {
        return (NotificationManager) mContext.getSystemService(Context.NOTIFICATION_SERVICE);
    }

    private void postInitialNotification(ScanResult recommendedNetwork) {
        if (mRecommendedNetwork != null
                && TextUtils.equals(mRecommendedNetwork.SSID, recommendedNetwork.SSID)) {
            return;
        }

        postNotification(mNotificationBuilder.createConnectToAvailableNetworkNotification(mTag,
                recommendedNetwork));

        if (mState == STATE_NO_NOTIFICATION) {
            mWifiMetrics.incrementConnectToNetworkNotification(mTag,
                    ConnectToNetworkNotificationAndActionCount.NOTIFICATION_RECOMMEND_NETWORK);
        } else {
            mWifiMetrics.incrementNumNetworkRecommendationUpdates(mTag);
        }
        mState = STATE_SHOWING_RECOMMENDATION_NOTIFICATION;
        mRecommendedNetwork = recommendedNetwork;
        mNotificationRepeatTime = mClock.getWallClockMillis() + mNotificationRepeatDelay;
    }

    private void postNotification(Notification notification) {
        getNotificationManager().notify(mSystemMessageNotificationId, notification);
    }

    private void handleConnectToNetworkAction() {
        mWifiMetrics.incrementConnectToNetworkNotificationAction(mTag, mState,
                ConnectToNetworkNotificationAndActionCount.ACTION_CONNECT_TO_NETWORK);
        if (mState != STATE_SHOWING_RECOMMENDATION_NOTIFICATION) {
            return;
        }
        postNotification(mNotificationBuilder.createNetworkConnectingNotification(mTag,
                mRecommendedNetwork));
        mWifiMetrics.incrementConnectToNetworkNotification(mTag,
                ConnectToNetworkNotificationAndActionCount.NOTIFICATION_CONNECTING_TO_NETWORK);

        Log.d(mTag,
                "User initiated connection to recommended network: "
                        + "\"" + mRecommendedNetwork.SSID + "\"");
        WifiConfiguration network = createRecommendedNetworkConfig(mRecommendedNetwork);

        NetworkUpdateResult result = mConfigManager.addOrUpdateNetwork(network, Process.WIFI_UID);
        if (result.isSuccess()) {
            mWifiMetrics.setNominatorForNetwork(result.netId, mNominatorId);

            Message msg = Message.obtain();
            msg.what = WifiManager.CONNECT_NETWORK;
            msg.arg1 = result.netId;
            msg.obj = null;
            msg.replyTo = mSrcMessenger;
            mClientModeImpl.sendMessage(msg);
            addNetworkToBlacklist(mRecommendedNetwork.SSID);
        }

        mState = STATE_CONNECTING_IN_NOTIFICATION;
        mHandler.postDelayed(
                () -> {
                    if (mState == STATE_CONNECTING_IN_NOTIFICATION) {
                        handleConnectionFailure();
                    }
                },
                TIME_TO_SHOW_CONNECTING_MILLIS);
    }

    private void addNetworkToBlacklist(String ssid) {
        mBlacklistedSsids.add(ssid);
        mWifiMetrics.setNetworkRecommenderBlacklistSize(mTag, mBlacklistedSsids.size());
        mConfigManager.saveToStore(false /* forceWrite */);
        Log.d(mTag, "Network is added to the network notification blacklist: "
                + "\"" + ssid + "\"");
    }

    private void removeNetworkFromBlacklist(String ssid) {
        if (ssid == null) {
            return;
        }
        if (!mBlacklistedSsids.remove(ssid)) {
            return;
        }
        mWifiMetrics.setNetworkRecommenderBlacklistSize(mTag, mBlacklistedSsids.size());
        mConfigManager.saveToStore(false /* forceWrite */);
        Log.d(mTag, "Network is removed from the network notification blacklist: "
                + "\"" + ssid + "\"");
    }

    WifiConfiguration createRecommendedNetworkConfig(ScanResult recommendedNetwork) {
        return ScanResultUtil.createNetworkFromScanResult(recommendedNetwork);
    }

    private void handleSeeAllNetworksAction() {
        mWifiMetrics.incrementConnectToNetworkNotificationAction(mTag, mState,
                ConnectToNetworkNotificationAndActionCount.ACTION_PICK_WIFI_NETWORK);
        startWifiSettings();
    }

    private void startWifiSettings() {
        // Close notification drawer before opening the picker.
        mContext.sendBroadcast(new Intent(Intent.ACTION_CLOSE_SYSTEM_DIALOGS));
        mContext.startActivity(
                new Intent(Settings.ACTION_WIFI_SETTINGS)
                        .addFlags(Intent.FLAG_ACTIVITY_NEW_TASK));
        clearPendingNotification(false /* resetRepeatTime */);
    }

    private void handleConnectionAttemptFailedToSend() {
        handleConnectionFailure();
        mWifiMetrics.incrementNumNetworkConnectMessageFailedToSend(mTag);
    }

    private void handlePickWifiNetworkAfterConnectFailure() {
        mWifiMetrics.incrementConnectToNetworkNotificationAction(mTag, mState,
                ConnectToNetworkNotificationAndActionCount
                        .ACTION_PICK_WIFI_NETWORK_AFTER_CONNECT_FAILURE);
        startWifiSettings();
    }

    private void handleUserDismissedAction() {
        Log.d(mTag, "User dismissed notification with state=" + mState);
        mWifiMetrics.incrementConnectToNetworkNotificationAction(mTag, mState,
                ConnectToNetworkNotificationAndActionCount.ACTION_USER_DISMISSED_NOTIFICATION);
        if (mState == STATE_SHOWING_RECOMMENDATION_NOTIFICATION) {
            // blacklist dismissed network
            addNetworkToBlacklist(mRecommendedNetwork.SSID);
        }
        resetStateAndDelayNotification();
    }

    private void resetStateAndDelayNotification() {
        mState = STATE_NO_NOTIFICATION;
        mNotificationRepeatTime = System.currentTimeMillis() + mNotificationRepeatDelay;
        mRecommendedNetwork = null;
    }

    /** Dump this network notifier's state. */
    public void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
        pw.println(mTag + ": ");
        pw.println("mSettingEnabled " + mSettingEnabled);
        pw.println("currentTime: " + mClock.getWallClockMillis());
        pw.println("mNotificationRepeatTime: " + mNotificationRepeatTime);
        pw.println("mState: " + mState);
        pw.println("mBlacklistedSsids: " + mBlacklistedSsids.toString());
    }

    private class AvailableNetworkNotifierStoreData implements SsidSetStoreData.DataSource {
        @Override
        public Set<String> getSsids() {
            return new ArraySet<>(mBlacklistedSsids);
        }

        @Override
        public void setSsids(Set<String> ssidList) {
            mBlacklistedSsids.addAll(ssidList);
            mWifiMetrics.setNetworkRecommenderBlacklistSize(mTag, mBlacklistedSsids.size());
        }
    }

    private class NotificationEnabledSettingObserver extends ContentObserver {
        NotificationEnabledSettingObserver(Handler handler) {
            super(handler);
        }

        public void register() {
            mFrameworkFacade.registerContentObserver(mContext,
                    Settings.Global.getUriFor(mToggleSettingsName), true, this);
            mSettingEnabled = getValue();
        }

        @Override
        public void onChange(boolean selfChange) {
            super.onChange(selfChange);
            mSettingEnabled = getValue();
            clearPendingNotification(true /* resetRepeatTime */);
        }

        private boolean getValue() {
            boolean enabled =
                    mFrameworkFacade.getIntegerSetting(mContext, mToggleSettingsName, 1) == 1;
            mWifiMetrics.setIsWifiNetworksAvailableNotificationEnabled(mTag, enabled);
            Log.d(mTag, "Settings toggle enabled=" + enabled);
            return enabled;
        }
    }
}