/*
 * Copyright (c) 2010-2019 Belledonne Communications SARL.
 *
 * This file is part of linphone-android
 * (see https://www.linphone.org).
 *
 * 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.linphone.settings;

import android.content.Intent;
import android.os.Bundle;
import android.text.InputType;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import androidx.annotation.Nullable;
import java.util.ArrayList;
import java.util.List;
import org.linphone.LinphoneManager;
import org.linphone.R;
import org.linphone.assistant.PhoneAccountLinkingAssistantActivity;
import org.linphone.core.AVPFMode;
import org.linphone.core.Address;
import org.linphone.core.AuthInfo;
import org.linphone.core.Core;
import org.linphone.core.Factory;
import org.linphone.core.NatPolicy;
import org.linphone.core.ProxyConfig;
import org.linphone.core.TransportType;
import org.linphone.core.tools.Log;
import org.linphone.settings.widget.BasicSetting;
import org.linphone.settings.widget.ListSetting;
import org.linphone.settings.widget.SettingListenerBase;
import org.linphone.settings.widget.SwitchSetting;
import org.linphone.settings.widget.TextSetting;
import org.linphone.utils.PushNotificationUtils;

public class AccountSettingsFragment extends SettingsFragment {
    private View mRootView;
    private int mAccountIndex;
    private ProxyConfig mProxyConfig;
    private AuthInfo mAuthInfo;
    private boolean mIsNewlyCreatedAccount;

    private TextSetting mUsername,
            mUserId,
            mPassword,
            mDomain,
            mDisplayName,
            mProxy,
            mStun,
            mExpire,
            mPrefix,
            mAvpfInterval;
    private SwitchSetting mDisable,
            mUseAsDefault,
            mOutboundProxy,
            mIce,
            mAvpf,
            mReplacePlusBy00,
            mPush;
    private BasicSetting mChangePassword, mDeleteAccount, mLinkAccount;
    private ListSetting mTransport;

    @Nullable
    @Override
    public View onCreateView(
            LayoutInflater inflater, @Nullable ViewGroup container, Bundle savedInstanceState) {
        mRootView = inflater.inflate(R.layout.settings_account, container, false);

        loadSettings();

        mIsNewlyCreatedAccount = true;
        mAccountIndex = getArguments().getInt("Account", -1);
        if (mAccountIndex == -1 && savedInstanceState != null) {
            mAccountIndex = savedInstanceState.getInt("Account", -1);
        }

        mProxyConfig = null;
        Core core = LinphoneManager.getCore();
        if (mAccountIndex >= 0 && core != null) {
            ProxyConfig[] proxyConfigs = core.getProxyConfigList();
            if (proxyConfigs.length > mAccountIndex) {
                mProxyConfig = proxyConfigs[mAccountIndex];
                mIsNewlyCreatedAccount = false;
            } else {
                Log.e("[Account Settings] Proxy config not found !");
            }
        }

        return mRootView;
    }

    @Override
    public void onSaveInstanceState(Bundle outState) {
        super.onSaveInstanceState(outState);
        outState.putInt("Account", mAccountIndex);
    }

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

        updateValues();
    }

    @Override
    public void onPause() {
        super.onPause();
        if (mIsNewlyCreatedAccount) {
            Core core = LinphoneManager.getCore();
            if (core != null && mProxyConfig != null && mAuthInfo != null) {
                core.addAuthInfo(mAuthInfo);
                core.addProxyConfig(mProxyConfig);
                if (mUseAsDefault.isChecked()) {
                    core.setDefaultProxyConfig(mProxyConfig);
                }
            }
        }
    }

    private void loadSettings() {
        mUsername = mRootView.findViewById(R.id.pref_username);

        mUserId = mRootView.findViewById(R.id.pref_auth_userid);

        mPassword = mRootView.findViewById(R.id.pref_passwd);
        mPassword.setInputType(InputType.TYPE_CLASS_TEXT | InputType.TYPE_TEXT_VARIATION_PASSWORD);

        mDomain = mRootView.findViewById(R.id.pref_domain);

        mDisplayName = mRootView.findViewById(R.id.pref_display_name);
        mDisplayName.setInputType(
                InputType.TYPE_CLASS_TEXT | InputType.TYPE_TEXT_VARIATION_PERSON_NAME);

        mProxy = mRootView.findViewById(R.id.pref_proxy);
        mProxy.setInputType(InputType.TYPE_CLASS_TEXT | InputType.TYPE_TEXT_VARIATION_URI);

        mStun = mRootView.findViewById(R.id.pref_stun_server);
        mStun.setInputType(InputType.TYPE_CLASS_TEXT | InputType.TYPE_TEXT_VARIATION_URI);

        mExpire = mRootView.findViewById(R.id.pref_expire);
        mExpire.setInputType(InputType.TYPE_CLASS_NUMBER);

        mPrefix = mRootView.findViewById(R.id.pref_prefix);
        mPrefix.setInputType(InputType.TYPE_CLASS_NUMBER);

        mAvpfInterval = mRootView.findViewById(R.id.pref_avpf_rr_interval);
        mAvpfInterval.setInputType(InputType.TYPE_CLASS_NUMBER);

        mDisable = mRootView.findViewById(R.id.pref_disable_account);

        mUseAsDefault = mRootView.findViewById(R.id.pref_default_account);

        mOutboundProxy = mRootView.findViewById(R.id.pref_enable_outbound_proxy);

        mIce = mRootView.findViewById(R.id.pref_ice_enable);

        mAvpf = mRootView.findViewById(R.id.pref_avpf);

        mReplacePlusBy00 = mRootView.findViewById(R.id.pref_escape_plus);

        mPush = mRootView.findViewById(R.id.pref_push_notification);
        mPush.setVisibility(
                PushNotificationUtils.isAvailable(getActivity()) ? View.VISIBLE : View.GONE);

        mChangePassword = mRootView.findViewById(R.id.pref_change_password);
        mChangePassword.setVisibility(View.GONE); // TODO add feature

        mDeleteAccount = mRootView.findViewById(R.id.pref_delete_account);

        mLinkAccount = mRootView.findViewById(R.id.pref_link_account);

        mTransport = mRootView.findViewById(R.id.pref_transport);
        initTransportList();
    }

    private void setListeners() {
        mUsername.setListener(
                new SettingListenerBase() {
                    @Override
                    public void onTextValueChanged(String newValue) {
                        if (newValue.isEmpty()) {
                            return;
                        }

                        if (mAuthInfo != null) {
                            mAuthInfo.setUsername(newValue);
                        } else {
                            Log.e("[Account Settings] No auth info !");
                        }

                        if (mProxyConfig != null) {
                            mProxyConfig.edit();
                            Address identity = mProxyConfig.getIdentityAddress();
                            if (identity != null) {
                                identity.setUsername(newValue);
                            }
                            mProxyConfig.setIdentityAddress(identity);
                            mProxyConfig.done();
                        } else {
                            Log.e("[Account Settings] No proxy config !");
                        }
                    }
                });

        mUserId.setListener(
                new SettingListenerBase() {
                    @Override
                    public void onTextValueChanged(String newValue) {
                        if (mAuthInfo != null) {
                            mAuthInfo.setUserid(newValue);

                            Core core = LinphoneManager.getCore();
                            if (core != null) {
                                core.refreshRegisters();
                            }
                        } else {
                            Log.e("[Account Settings] No auth info !");
                        }
                    }
                });

        mPassword.setListener(
                new SettingListenerBase() {
                    @Override
                    public void onTextValueChanged(String newValue) {
                        if (mAuthInfo != null) {
                            mAuthInfo.setHa1(null);
                            mAuthInfo.setPassword(newValue);
                            // Reset algorithm to generate correct hash depending on
                            // algorithm set in next to come 401
                            mAuthInfo.setAlgorithm(null);
                            Core core = LinphoneManager.getCore();
                            if (core != null) {
                                core.addAuthInfo(mAuthInfo);
                                core.refreshRegisters();
                            }
                        } else {
                            Log.e("[Account Settings] No auth info !");
                        }
                    }
                });

        mDomain.setListener(
                new SettingListenerBase() {
                    @Override
                    public void onTextValueChanged(String newValue) {
                        if (newValue.isEmpty()) {
                            return;
                        }
                        if (newValue.contains(":")) {
                            Log.e(
                                    "[Account Settings] Do not specify port information inside domain field !");
                            return;
                        }

                        if (mAuthInfo != null) {
                            mAuthInfo.setDomain(newValue);
                        } else {
                            Log.e("[Account Settings] No auth info !");
                        }

                        if (mProxyConfig != null) {
                            mProxyConfig.edit();
                            Address identity = mProxyConfig.getIdentityAddress();
                            if (identity != null) {
                                identity.setDomain(newValue);
                            }
                            mProxyConfig.setIdentityAddress(identity);
                            mProxyConfig.done();
                        } else {
                            Log.e("[Account Settings] No proxy config !");
                        }
                    }
                });

        mDisplayName.setListener(
                new SettingListenerBase() {
                    @Override
                    public void onTextValueChanged(String newValue) {
                        if (mProxyConfig != null) {
                            mProxyConfig.edit();
                            Address identity = mProxyConfig.getIdentityAddress();
                            if (identity != null) {
                                identity.setDisplayName(newValue);
                            }
                            mProxyConfig.setIdentityAddress(identity);
                            mProxyConfig.done();
                        } else {
                            Log.e("[Account Settings] No proxy config !");
                        }
                    }
                });

        mProxy.setListener(
                new SettingListenerBase() {
                    @Override
                    public void onTextValueChanged(String newValue) {
                        if (mProxyConfig != null) {
                            mProxyConfig.edit();
                            Address proxy = Factory.instance().createAddress(newValue);
                            if (proxy != null) {
                                mProxyConfig.setServerAddr(proxy.asString());
                                if (mOutboundProxy.isChecked()) {
                                    mProxyConfig.setRoute(proxy.asString());
                                }
                                mTransport.setValue(proxy.getTransport().toInt());
                            }
                            mProxyConfig.done();
                        } else {
                            Log.e("[Account Settings] No proxy config !");
                        }
                    }
                });

        mStun.setListener(
                new SettingListenerBase() {
                    @Override
                    public void onTextValueChanged(String newValue) {
                        if (mProxyConfig != null) {
                            mProxyConfig.edit();
                            NatPolicy natPolicy = mProxyConfig.getNatPolicy();
                            if (natPolicy == null) {
                                Core core = LinphoneManager.getCore();
                                if (core != null) {
                                    natPolicy = core.createNatPolicy();
                                    mProxyConfig.setNatPolicy(natPolicy);
                                }
                            }
                            if (natPolicy != null) {
                                natPolicy.setStunServer(newValue);
                            }
                            if (newValue == null || newValue.isEmpty()) {
                                mIce.setChecked(false);
                            }
                            mIce.setEnabled(newValue != null && !newValue.isEmpty());
                            mProxyConfig.done();
                        } else {
                            Log.e("[Account Settings] No proxy config !");
                        }
                    }
                });

        mExpire.setListener(
                new SettingListenerBase() {
                    @Override
                    public void onTextValueChanged(String newValue) {
                        if (mProxyConfig != null) {
                            mProxyConfig.edit();
                            try {
                                mProxyConfig.setExpires(Integer.parseInt(newValue));
                            } catch (NumberFormatException nfe) {
                                Log.e(nfe);
                            }
                            mProxyConfig.done();
                        } else {
                            Log.e("[Account Settings] No proxy config !");
                        }
                    }
                });

        mPrefix.setListener(
                new SettingListenerBase() {
                    @Override
                    public void onTextValueChanged(String newValue) {
                        if (mProxyConfig != null) {
                            mProxyConfig.edit();
                            mProxyConfig.setDialPrefix(newValue);
                            mProxyConfig.done();
                        } else {
                            Log.e("[Account Settings] No proxy config !");
                        }
                    }
                });

        mAvpfInterval.setListener(
                new SettingListenerBase() {
                    @Override
                    public void onTextValueChanged(String newValue) {
                        if (mProxyConfig != null) {
                            mProxyConfig.edit();
                            try {
                                mProxyConfig.setAvpfRrInterval(Integer.parseInt(newValue));
                            } catch (NumberFormatException nfe) {
                                Log.e(nfe);
                            }
                            mProxyConfig.done();
                        } else {
                            Log.e("[Account Settings] No proxy config !");
                        }
                    }
                });

        mDisable.setListener(
                new SettingListenerBase() {
                    @Override
                    public void onBoolValueChanged(boolean newValue) {
                        if (mProxyConfig != null) {
                            mProxyConfig.edit();
                            mProxyConfig.enableRegister(!newValue);
                            mProxyConfig.done();
                        } else {
                            Log.e("[Account Settings] No proxy config !");
                        }
                    }
                });

        mUseAsDefault.setListener(
                new SettingListenerBase() {
                    @Override
                    public void onBoolValueChanged(boolean newValue) {
                        if (mProxyConfig != null) {
                            Core core = LinphoneManager.getCore();
                            if (core != null && newValue) {
                                core.setDefaultProxyConfig(mProxyConfig);
                                mUseAsDefault.setEnabled(false);
                            }
                            ((SettingsActivity) getActivity())
                                    .getSideMenuFragment()
                                    .displayAccountsInSideMenu();
                        } else {
                            Log.e("[Account Settings] No proxy config !");
                        }
                    }
                });

        mOutboundProxy.setListener(
                new SettingListenerBase() {
                    @Override
                    public void onBoolValueChanged(boolean newValue) {
                        if (mProxyConfig != null) {
                            mProxyConfig.edit();
                            if (newValue) {
                                mProxyConfig.setRoute(mProxy.getValue());
                            } else {
                                mProxyConfig.setRoute(null);
                            }
                            mProxyConfig.done();
                        } else {
                            Log.e("[Account Settings] No proxy config !");
                        }
                    }
                });

        mIce.setListener(
                new SettingListenerBase() {
                    @Override
                    public void onBoolValueChanged(boolean newValue) {
                        if (mProxyConfig != null) {
                            mProxyConfig.edit();

                            NatPolicy natPolicy = mProxyConfig.getNatPolicy();
                            if (natPolicy == null) {
                                Core core = LinphoneManager.getCore();
                                if (core != null) {
                                    natPolicy = core.createNatPolicy();
                                    mProxyConfig.setNatPolicy(natPolicy);
                                }
                            }

                            if (natPolicy != null) {
                                natPolicy.enableIce(newValue);
                            }
                            mProxyConfig.done();
                        } else {
                            Log.e("[Account Settings] No proxy config !");
                        }
                    }
                });

        mAvpf.setListener(
                new SettingListenerBase() {
                    @Override
                    public void onBoolValueChanged(boolean newValue) {
                        if (mProxyConfig != null) {
                            mProxyConfig.edit();
                            mProxyConfig.setAvpfMode(
                                    newValue ? AVPFMode.Enabled : AVPFMode.Disabled);
                            mAvpfInterval.setEnabled(mProxyConfig.avpfEnabled());
                            mProxyConfig.done();
                        } else {
                            Log.e("[Account Settings] No proxy config !");
                        }
                    }
                });

        mReplacePlusBy00.setListener(
                new SettingListenerBase() {
                    @Override
                    public void onBoolValueChanged(boolean newValue) {
                        if (mProxyConfig != null) {
                            mProxyConfig.edit();
                            mProxyConfig.setDialEscapePlus(newValue);
                            mProxyConfig.done();
                        } else {
                            Log.e("[Account Settings] No proxy config !");
                        }
                    }
                });

        mPush.setListener(
                new SettingListenerBase() {
                    @Override
                    public void onBoolValueChanged(boolean newValue) {
                        if (mProxyConfig != null) {
                            mProxyConfig.edit();
                            mProxyConfig.setPushNotificationAllowed(newValue);
                            mProxyConfig.done();
                        } else {
                            Log.e("[Account Settings] No proxy config !");
                        }
                    }
                });

        mChangePassword.setListener(
                new SettingListenerBase() {
                    @Override
                    public void onClicked() {
                        // TODO add feature
                    }
                });

        mDeleteAccount.setListener(
                new SettingListenerBase() {
                    @Override
                    public void onClicked() {
                        Core core = LinphoneManager.getCore();
                        if (core != null) {
                            if (mProxyConfig != null) {
                                core.removeProxyConfig(mProxyConfig);
                            }
                            if (mAuthInfo != null) {
                                core.removeAuthInfo(mAuthInfo);
                            }
                        }

                        // Set a new default proxy config if the current one has been removed
                        if (core != null && core.getDefaultProxyConfig() == null) {
                            ProxyConfig[] proxyConfigs = core.getProxyConfigList();
                            if (proxyConfigs.length > 0) {
                                core.setDefaultProxyConfig(proxyConfigs[0]);
                            }
                        }

                        ((SettingsActivity) getActivity())
                                .getSideMenuFragment()
                                .displayAccountsInSideMenu();
                        ((SettingsActivity) getActivity()).goBack();
                    }
                });

        mLinkAccount.setListener(
                new SettingListenerBase() {
                    @Override
                    public void onClicked() {
                        Intent assistant = new Intent();
                        assistant.setClass(
                                getActivity(), PhoneAccountLinkingAssistantActivity.class);
                        assistant.putExtra("AccountNumber", mAccountIndex);
                        startActivity(assistant);
                    }
                });

        mTransport.setListener(
                new SettingListenerBase() {
                    @Override
                    public void onListValueChanged(int position, String newLabel, String newValue) {
                        if (mProxyConfig != null) {
                            mProxyConfig.edit();
                            String server = mProxyConfig.getServerAddr();
                            Address serverAddr = Factory.instance().createAddress(server);
                            if (serverAddr != null) {
                                try {
                                    serverAddr.setTransport(
                                            TransportType.fromInt(Integer.parseInt(newValue)));
                                    server = serverAddr.asString();
                                    mProxyConfig.setServerAddr(server);
                                    if (mOutboundProxy.isChecked()) {
                                        mProxyConfig.setRoute(server);
                                    }
                                    mProxy.setValue(server);
                                } catch (NumberFormatException nfe) {
                                    Log.e(nfe);
                                }
                            }
                            mProxyConfig.done();
                        } else {
                            Log.e("[Account Settings] No proxy config !");
                        }
                    }
                });
    }

    private void updateValues() {
        Core core = LinphoneManager.getCore();
        if (core == null) return;

        // Create a proxy config if there is none
        if (mProxyConfig == null) {
            // Ensure the default configuration is loaded first
            String defaultConfig = LinphonePreferences.instance().getDefaultDynamicConfigFile();
            core.loadConfigFromXml(defaultConfig);
            mProxyConfig = core.createProxyConfig();
            mAuthInfo = Factory.instance().createAuthInfo(null, null, null, null, null, null);
            mIsNewlyCreatedAccount = true;
        }

        if (mProxyConfig != null) {
            Address identityAddress = mProxyConfig.getIdentityAddress();
            mAuthInfo = mProxyConfig.findAuthInfo();

            NatPolicy natPolicy = mProxyConfig.getNatPolicy();
            if (natPolicy == null) {
                natPolicy = core.createNatPolicy();
                core.setNatPolicy(natPolicy);
            }

            if (mAuthInfo != null) {
                mUserId.setValue(mAuthInfo.getUserid());
                // If password is hashed we can't display it
                mPassword.setValue(mAuthInfo.getPassword());
            }

            mUsername.setValue(identityAddress.getUsername());

            mDomain.setValue(identityAddress.getDomain());

            mDisplayName.setValue(identityAddress.getDisplayName());

            mProxy.setValue(mProxyConfig.getServerAddr());

            mStun.setValue(natPolicy.getStunServer());

            mExpire.setValue(mProxyConfig.getExpires());

            mPrefix.setValue(mProxyConfig.getDialPrefix());

            mAvpfInterval.setValue(mProxyConfig.getAvpfRrInterval());
            mAvpfInterval.setEnabled(mProxyConfig.avpfEnabled());

            mDisable.setChecked(!mProxyConfig.registerEnabled());

            mUseAsDefault.setChecked(mProxyConfig.equals(core.getDefaultProxyConfig()));
            mUseAsDefault.setEnabled(!mUseAsDefault.isChecked());

            String[] routes = mProxyConfig.getRoutes();
            mOutboundProxy.setChecked(routes != null && routes.length > 0);

            mIce.setChecked(natPolicy.iceEnabled());
            mIce.setEnabled(
                    natPolicy.getStunServer() != null && !natPolicy.getStunServer().isEmpty());

            mAvpf.setChecked(mProxyConfig.avpfEnabled());

            mReplacePlusBy00.setChecked(mProxyConfig.getDialEscapePlus());

            mPush.setChecked(mProxyConfig.isPushNotificationAllowed());

            Address proxy = Factory.instance().createAddress(mProxyConfig.getServerAddr());
            if (proxy != null) {
                mTransport.setValue(proxy.getTransport().toInt());
            }

            mLinkAccount.setEnabled(
                    mProxyConfig.getDomain().equals(getString(R.string.default_domain)));
        }

        setListeners();
    }

    private void initTransportList() {
        List<String> entries = new ArrayList<>();
        List<String> values = new ArrayList<>();

        entries.add(getString(R.string.pref_transport_udp));
        values.add(String.valueOf(TransportType.Udp.toInt()));
        entries.add(getString(R.string.pref_transport_tcp));
        values.add(String.valueOf(TransportType.Tcp.toInt()));

        if (!getResources().getBoolean(R.bool.disable_all_security_features_for_markets)) {
            entries.add(getString(R.string.pref_transport_tls));
            values.add(String.valueOf(TransportType.Tls.toInt()));
        }

        mTransport.setItems(entries, values);
    }
}