/*
* Copyright (C) 2014 Samsung System LSI
* 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.bluetooth.map;

import android.content.BroadcastReceiver;
import android.content.ContentResolver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.content.pm.PackageManager;
import android.content.pm.ResolveInfo;
import android.database.ContentObserver;
import android.net.Uri;
import android.util.Log;

import com.android.bluetooth.mapapi.BluetoothMapContract;

import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Objects;

/**
 * Class to construct content observers for for email applications on the system.
 *
 *
 */

public class BluetoothMapAppObserver {

    private static final String TAG = "BluetoothMapAppObserver";

    private static final boolean D = BluetoothMapService.DEBUG;
    private static final boolean V = BluetoothMapService.VERBOSE;
    /*  */
    private LinkedHashMap<BluetoothMapAccountItem, ArrayList<BluetoothMapAccountItem>> mFullList;
    private LinkedHashMap<String, ContentObserver> mObserverMap =
            new LinkedHashMap<String, ContentObserver>();
    private ContentResolver mResolver;
    private Context mContext;
    private BroadcastReceiver mReceiver;
    private PackageManager mPackageManager = null;
    BluetoothMapAccountLoader mLoader;
    BluetoothMapService mMapService = null;
    private boolean mRegisteredReceiver = false;

    public BluetoothMapAppObserver(final Context context, BluetoothMapService mapService) {
        mContext = context;
        mMapService = mapService;
        mResolver = context.getContentResolver();
        mLoader = new BluetoothMapAccountLoader(mContext);
        mFullList = mLoader.parsePackages(false); /* Get the current list of apps */
        createReceiver();
        initObservers();
    }


    private BluetoothMapAccountItem getApp(String authoritiesName) {
        if (V) {
            Log.d(TAG, "getApp(): Looking for " + authoritiesName);
        }
        for (BluetoothMapAccountItem app : mFullList.keySet()) {
            if (V) {
                Log.d(TAG, "  Comparing: " + app.getProviderAuthority());
            }
            if (app.getProviderAuthority().equals(authoritiesName)) {
                if (V) {
                    Log.d(TAG, "  found " + app.mBase_uri_no_account);
                }
                return app;
            }
        }
        if (V) {
            Log.d(TAG, "  NOT FOUND!");
        }
        return null;
    }

    private void handleAccountChanges(String packageNameWithProvider) {

        if (D) {
            Log.d(TAG, "handleAccountChanges (packageNameWithProvider: " + packageNameWithProvider
                    + "\n");
        }
        //String packageName = packageNameWithProvider.replaceFirst("\\.[^\\.]+$", "");
        BluetoothMapAccountItem app = getApp(packageNameWithProvider);
        if (app != null) {
            ArrayList<BluetoothMapAccountItem> newAccountList = mLoader.parseAccounts(app);
            ArrayList<BluetoothMapAccountItem> oldAccountList = mFullList.get(app);
            ArrayList<BluetoothMapAccountItem> addedAccountList =
                    (ArrayList<BluetoothMapAccountItem>) newAccountList.clone();
            // Same as oldAccountList.clone
            ArrayList<BluetoothMapAccountItem> removedAccountList = mFullList.get(app);
            if (oldAccountList == null) {
                oldAccountList = new ArrayList<BluetoothMapAccountItem>();
            }
            if (removedAccountList == null) {
                removedAccountList = new ArrayList<BluetoothMapAccountItem>();
            }

            mFullList.put(app, newAccountList);
            for (BluetoothMapAccountItem newAcc : newAccountList) {
                for (BluetoothMapAccountItem oldAcc : oldAccountList) {
                    if (Objects.equals(newAcc.getId(), oldAcc.getId())) {
                        // For each match remove from both removed and added lists
                        removedAccountList.remove(oldAcc);
                        addedAccountList.remove(newAcc);
                        if (!newAcc.getName().equals(oldAcc.getName()) && newAcc.mIsChecked) {
                            // Name Changed and the acc is visible - Change Name in SDP record
                            mMapService.updateMasInstances(
                                    BluetoothMapService.UPDATE_MAS_INSTANCES_ACCOUNT_RENAMED);
                            if (V) {
                                Log.d(TAG, "    UPDATE_MAS_INSTANCES_ACCOUNT_RENAMED");
                            }
                        }
                        if (newAcc.mIsChecked != oldAcc.mIsChecked) {
                            // Visibility changed
                            if (newAcc.mIsChecked) {
                                // account added - create SDP record
                                mMapService.updateMasInstances(
                                        BluetoothMapService.UPDATE_MAS_INSTANCES_ACCOUNT_ADDED);
                                if (V) {
                                    Log.d(TAG, "UPDATE_MAS_INSTANCES_ACCOUNT_ADDED "
                                            + "isChecked changed");
                                }
                            } else {
                                // account removed - remove SDP record
                                mMapService.updateMasInstances(
                                        BluetoothMapService.UPDATE_MAS_INSTANCES_ACCOUNT_REMOVED);
                                if (V) {
                                    Log.d(TAG, "    UPDATE_MAS_INSTANCES_ACCOUNT_REMOVED "
                                            + "isChecked changed");
                                }
                            }
                        }
                        break;
                    }
                }
            }
            // Notify on any removed accounts
            for (BluetoothMapAccountItem removedAcc : removedAccountList) {
                mMapService.updateMasInstances(
                        BluetoothMapService.UPDATE_MAS_INSTANCES_ACCOUNT_REMOVED);
                if (V) {
                    Log.d(TAG, "    UPDATE_MAS_INSTANCES_ACCOUNT_REMOVED " + removedAcc);
                }
            }
            // Notify on any new accounts
            for (BluetoothMapAccountItem addedAcc : addedAccountList) {
                mMapService.updateMasInstances(
                        BluetoothMapService.UPDATE_MAS_INSTANCES_ACCOUNT_ADDED);
                if (V) {
                    Log.d(TAG, "    UPDATE_MAS_INSTANCES_ACCOUNT_ADDED " + addedAcc);
                }
            }

        } else {
            Log.e(TAG, "Received change notification on package not registered for notifications!");

        }
    }

    /**
     * Adds a new content observer to the list of content observers.
     * The key for the observer is the uri as string
     * @param app app item for the package that supports MAP email
     */

    public void registerObserver(BluetoothMapAccountItem app) {
        Uri uri = BluetoothMapContract.buildAccountUri(app.getProviderAuthority());
        if (V) {
            Log.d(TAG, "registerObserver for URI " + uri.toString() + "\n");
        }
        ContentObserver observer = new ContentObserver(null) {
            @Override
            public void onChange(boolean selfChange) {
                onChange(selfChange, null);
            }

            @Override
            public void onChange(boolean selfChange, Uri uri) {
                if (V) {
                    Log.d(TAG,
                            "onChange on thread: " + Thread.currentThread().getId() + " Uri: " + uri
                                    + " selfchange: " + selfChange);
                }
                if (uri != null) {
                    handleAccountChanges(uri.getHost());
                } else {
                    Log.e(TAG, "Unable to handle change as the URI is NULL!");
                }

            }
        };
        mObserverMap.put(uri.toString(), observer);
        //False "notifyForDescendents" : Get notified whenever a change occurs to the exact URI.
        mResolver.registerContentObserver(uri, false, observer);
    }

    public void unregisterObserver(BluetoothMapAccountItem app) {
        Uri uri = BluetoothMapContract.buildAccountUri(app.getProviderAuthority());
        if (V) {
            Log.d(TAG, "unregisterObserver(" + uri.toString() + ")\n");
        }
        mResolver.unregisterContentObserver(mObserverMap.get(uri.toString()));
        mObserverMap.remove(uri.toString());
    }

    private void initObservers() {
        if (D) {
            Log.d(TAG, "initObservers()");
        }
        for (BluetoothMapAccountItem app : mFullList.keySet()) {
            registerObserver(app);
        }
    }

    private void deinitObservers() {
        if (D) {
            Log.d(TAG, "deinitObservers()");
        }
        for (BluetoothMapAccountItem app : mFullList.keySet()) {
            unregisterObserver(app);
        }
    }

    private void createReceiver() {
        if (D) {
            Log.d(TAG, "createReceiver()\n");
        }
        IntentFilter intentFilter = new IntentFilter();
        intentFilter.addAction(Intent.ACTION_PACKAGE_ADDED);
        intentFilter.addAction(Intent.ACTION_PACKAGE_REMOVED);
        intentFilter.addDataScheme("package");
        mReceiver = new BroadcastReceiver() {
            @Override
            public void onReceive(Context context, Intent intent) {
                if (D) {
                    Log.d(TAG, "onReceive\n");
                }
                String action = intent.getAction();

                if (Intent.ACTION_PACKAGE_ADDED.equals(action)) {
                    Uri data = intent.getData();
                    String packageName = data.getEncodedSchemeSpecificPart();
                    if (D) {
                        Log.d(TAG, "The installed package is: " + packageName);
                    }

                    BluetoothMapUtils.TYPE msgType = BluetoothMapUtils.TYPE.NONE;
                    ResolveInfo resolveInfo = null;
                    Intent[] searchIntents = new Intent[2];
                    //Array <Intent> searchIntents = new Array <Intent>();
                    searchIntents[0] = new Intent(BluetoothMapContract.PROVIDER_INTERFACE_EMAIL);
                    searchIntents[1] = new Intent(BluetoothMapContract.PROVIDER_INTERFACE_IM);
                    // Find all installed packages and filter out those that support Bluetooth Map.

                    mPackageManager = mContext.getPackageManager();

                    for (Intent searchIntent : searchIntents) {
                        List<ResolveInfo> resInfos =
                                mPackageManager.queryIntentContentProviders(searchIntent, 0);
                        if (resInfos != null) {
                            if (D) {
                                Log.d(TAG,
                                        "Found " + resInfos.size() + " application(s) with intent "
                                                + searchIntent.getAction());
                            }
                            for (ResolveInfo rInfo : resInfos) {
                                if (rInfo != null) {
                                    // Find out if package contain Bluetooth MAP support
                                    if (packageName.equals(rInfo.providerInfo.packageName)) {
                                        resolveInfo = rInfo;
                                        if (Objects.equals(searchIntent.getAction(),
                                                BluetoothMapContract.PROVIDER_INTERFACE_EMAIL)) {
                                            msgType = BluetoothMapUtils.TYPE.EMAIL;
                                        } else if (Objects.equals(searchIntent.getAction(),
                                                BluetoothMapContract.PROVIDER_INTERFACE_IM)) {
                                            msgType = BluetoothMapUtils.TYPE.IM;
                                        }
                                        break;
                                    }
                                }
                            }
                        }
                    }
                    // if application found with Bluetooth MAP support add to list
                    if (resolveInfo != null) {
                        if (D) {
                            Log.d(TAG, "Found " + resolveInfo.providerInfo.packageName
                                    + " application of type " + msgType);
                        }
                        BluetoothMapAccountItem app =
                                mLoader.createAppItem(resolveInfo, false, msgType);
                        if (app != null) {
                            registerObserver(app);
                            // Add all accounts to mFullList
                            ArrayList<BluetoothMapAccountItem> newAccountList =
                                    mLoader.parseAccounts(app);
                            mFullList.put(app, newAccountList);
                        }
                    }

                } else if (Intent.ACTION_PACKAGE_REMOVED.equals(action)) {
                    Uri data = intent.getData();
                    String packageName = data.getEncodedSchemeSpecificPart();
                    if (D) {
                        Log.d(TAG, "The removed package is: " + packageName);
                    }
                    BluetoothMapAccountItem app = getApp(packageName);
                    /* Find the object and remove from fullList */
                    if (app != null) {
                        unregisterObserver(app);
                        mFullList.remove(app);
                    }
                }
            }
        };
        if (!mRegisteredReceiver) {
            try {
                mContext.registerReceiver(mReceiver, intentFilter);
                mRegisteredReceiver = true;
            } catch (Exception e) {
                Log.e(TAG, "Unable to register MapAppObserver receiver", e);
            }
        }
    }

    private void removeReceiver() {
        if (D) {
            Log.d(TAG, "removeReceiver()\n");
        }
        if (mRegisteredReceiver) {
            try {
                mRegisteredReceiver = false;
                mContext.unregisterReceiver(mReceiver);
            } catch (Exception e) {
                Log.e(TAG, "Unable to unregister mapAppObserver receiver", e);
            }
        }
    }

    /**
     * Method to get a list of the accounts (across all apps) that are set to be shared
     * through MAP.
     * @return Arraylist<BluetoothMapAccountItem> containing all enabled accounts
     */
    public ArrayList<BluetoothMapAccountItem> getEnabledAccountItems() {
        if (D) {
            Log.d(TAG, "getEnabledAccountItems()\n");
        }
        ArrayList<BluetoothMapAccountItem> list = new ArrayList<BluetoothMapAccountItem>();
        for (BluetoothMapAccountItem app : mFullList.keySet()) {
            if (app != null) {
                ArrayList<BluetoothMapAccountItem> accountList = mFullList.get(app);
                if (accountList != null) {
                    for (BluetoothMapAccountItem acc : accountList) {
                        if (acc.mIsChecked) {
                            list.add(acc);
                        }
                    }
                } else {
                    Log.w(TAG, "getEnabledAccountItems() - No AccountList enabled\n");
                }
            } else {
                Log.w(TAG, "getEnabledAccountItems() - No Account in App enabled\n");
            }
        }
        return list;
    }

    /**
     * Method to get a list of the accounts (across all apps).
     * @return Arraylist<BluetoothMapAccountItem> containing all accounts
     */
    public ArrayList<BluetoothMapAccountItem> getAllAccountItems() {
        if (D) {
            Log.d(TAG, "getAllAccountItems()\n");
        }
        ArrayList<BluetoothMapAccountItem> list = new ArrayList<BluetoothMapAccountItem>();
        for (BluetoothMapAccountItem app : mFullList.keySet()) {
            ArrayList<BluetoothMapAccountItem> accountList = mFullList.get(app);
            list.addAll(accountList);
        }
        return list;
    }


    /**
     * Cleanup all resources - must be called to avoid leaks.
     */
    public void shutdown() {
        deinitObservers();
        removeReceiver();
    }
}