/*
 * Copyright (c) 2010-2020 Belledonne Communications SARL.
 *
 * This file is part of linphone-iphone
 *
 * 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/>.
 */

#import "LinphoneCoreSettingsStore.h"
#import "Utils.h"
#import "PhoneMainView.h"

#include "linphone/linphone_tunnel.h"
#include "linphone/lpconfig.h"
#include <stdio.h>
#include <stdlib.h>

@implementation LinphoneCoreSettingsStore

- (id)init {
	self = [super init];
	if (self) {
		dict = [[NSMutableDictionary alloc] init];
		changedDict = [[NSMutableDictionary alloc] init];
	}
	return self;
}

- (void)setCString:(const char *)value forKey:(NSString *)key {
	id obj = @"";
	if (value)
		obj = [[NSString alloc] initWithCString:value encoding:NSUTF8StringEncoding];
	[self setObject:obj forKey:key];
}

- (NSString *)stringForKey:(NSString *)key {
	return [self objectForKey:key];
}

- (void)setObject:(id)value forKey:(NSString *)key {
	[dict setValue:value forKey:key];
	[changedDict setValue:[NSNumber numberWithBool:TRUE] forKey:key];
}

- (id)objectForKey:(NSString *)key {
	return [dict valueForKey:key];
}

- (BOOL)valueChangedForKey:(NSString *)key {
	return [[changedDict valueForKey:key] boolValue];
}

+ (int)validPort:(int)port {
	if (port < 0) {
		return 0;
	}
	if (port > 65535) {
		return 65535;
	}
	return port;
}

+ (BOOL)parsePortRange:(NSString *)text minPort:(int *)minPort maxPort:(int *)maxPort {
	/*NSError *error = nil;
	*minPort = -1;
	*maxPort = -1;
	NSRegularExpression *regex =
		[NSRegularExpression regularExpressionWithPattern:@"([0-9]+)(([^0-9]+)([0-9]+))?" options:0 error:&error];
	if (error != NULL)
		return FALSE;
	NSArray *matches = [regex matchesInString:text options:0 range:NSMakeRange(0, [text length])];
	if ([matches count] == 1) {
		NSTextCheckingResult *match = [matches objectAtIndex:0];
		bool range = [match rangeAtIndex:2].length > 0;
		if (!range) {
			NSRange rangeMinPort = [match rangeAtIndex:1];
			*minPort = [LinphoneCoreSettingsStore validPort:[[text substringWithRange:rangeMinPort] intValue]];
			*maxPort = *minPort;
			return TRUE;
		} else {
			NSRange rangeMinPort = [match rangeAtIndex:1];
			*minPort = [LinphoneCoreSettingsStore validPort:[[text substringWithRange:rangeMinPort] intValue]];
			NSRange rangeMaxPort = [match rangeAtIndex:4];
			*maxPort = [LinphoneCoreSettingsStore validPort:[[text substringWithRange:rangeMaxPort] intValue]];
			if (*minPort > *maxPort) {
				*minPort = *maxPort;
			}
			return TRUE;
		}
	}*/
	int err;

	err = sscanf(text.UTF8String, "%i - %i", minPort, maxPort);
	if (err == 0) {
		*minPort = *maxPort = -1;
	} else if (err == 1) {
		*maxPort = -1;
	}

	// Minimal port allowed
	if (*minPort < 1024) {
		*minPort = -1;
	}
	// Maximal port allowed
	if (*maxPort > 65535) {
		*maxPort = -1;
	}
	// minPort must be inferior or equal to maxPort
	if (*minPort > *maxPort) {
		*maxPort = *minPort;
	}

	return TRUE;
}

- (void)transformCodecsToKeys:(const MSList *)codecs {

	const MSList *elem = codecs;
	for (; elem != NULL; elem = elem->next) {
		PayloadType *pt = (PayloadType *)elem->data;
		NSString *pref = [LinphoneManager getPreferenceForCodec:pt->mime_type withRate:pt->clock_rate];
		if (pref) {
			bool_t value = linphone_core_payload_type_enabled(LC, pt);
			[self setBool:value forKey:pref];
		} else {
			LOGW(@"Codec %s/%i supported by core is not shown in iOS app config view.", pt->mime_type, pt->clock_rate);
		}
	}
}

- (void)transformAccountToKeys:(NSString *)username {
	const MSList *accountList = linphone_core_get_account_list(LC);
	while (username && accountList &&
		   strcmp(username.UTF8String,
				  linphone_address_get_username(linphone_account_params_get_identity_address(linphone_account_get_params(accountList->data)))) != 0) {
		accountList = accountList->next;
	}
	LinphoneAccount *account = NULL;

	// default values
	{
		[self setBool:NO forKey:@"account_pushnotification_preference"];
		[self setObject:@"" forKey:@"account_mandatory_username_preference"];
		[self setObject:@"" forKey:@"account_mandatory_domain_preference"];
		[self setCString:"" forKey:@"account_display_name_preference"];
		[self setObject:@"" forKey:@"account_proxy_preference"];
		[self setObject:@"udp" forKey:@"account_transport_preference"];
		[self setBool:NO forKey:@"account_outbound_proxy_preference"];
		[self setBool:NO forKey:@"account_avpf_preference"];
		[self setBool:YES forKey:@"account_is_default_preference"];
		[self setBool:YES forKey:@"account_is_enabled_preference"];
		[self setCString:"" forKey:@"account_userid_preference"];
		[self setCString:"" forKey:@"account_mandatory_password_preference"];
		[self setCString:"" forKey:@"ha1_preference"];
		[self setCString:"" forKey:@"ha1_algo_preference"];
		[self setInteger:-1 forKey:@"account_expire_preference"];
		[self setInteger:-1 forKey:@"current_proxy_config_preference"];
		[self setCString:"" forKey:@"account_prefix_preference"];
		[self setBool:NO forKey:@"account_substitute_+_by_00_preference"];
		[self setBool:NO forKey:@"account_ice_preference"];
		[self setCString:"" forKey:@"account_stun_preference"];
	}

	if (accountList) {
		account = accountList->data;
		LinphoneAccountParams const *accountParams = linphone_account_get_params(account);
		// root section
		{
			BOOL pushEnabled = linphone_account_params_get_push_notification_allowed(accountParams);
			[self setBool:pushEnabled forKey:@"account_pushnotification_preference"];

			const LinphoneAddress *identity_addr = linphone_account_params_get_identity_address(accountParams);
			const char *server_addr = linphone_account_params_get_server_addr(accountParams);
			LinphoneAddress *proxy_addr = linphone_core_interpret_url(LC, server_addr);
			if (identity_addr && proxy_addr) {
				int port = linphone_address_get_port(proxy_addr);

				[self setCString:linphone_address_get_username(identity_addr)
						  forKey:@"account_mandatory_username_preference"];
				[self setCString:linphone_address_get_display_name(identity_addr)
						  forKey:@"account_display_name_preference"];
				[self setCString:linphone_address_get_domain(identity_addr)
						  forKey:@"account_mandatory_domain_preference"];
				if (strcmp(linphone_address_get_domain(identity_addr), linphone_address_get_domain(proxy_addr)) != 0 ||
					port > 0) {
					char tmp[256] = {0};
					if (port > 0) {
						snprintf(tmp, sizeof(tmp) - 1, "%s:%i", linphone_address_get_domain(proxy_addr), port);
					} else
						snprintf(tmp, sizeof(tmp) - 1, "%s", linphone_address_get_domain(proxy_addr));
					[self setCString:tmp forKey:@"account_proxy_preference"];
				}
				const char *tname = "udp";
				switch (linphone_address_get_transport(proxy_addr)) {
					case LinphoneTransportTcp:
						tname = "tcp";
						break;
					case LinphoneTransportTls:
						tname = "tls";
						break;
					default:
						break;
				}
				linphone_address_unref(proxy_addr);
				[self setCString:tname forKey:@"account_transport_preference"];
			}

			[self setBool:(linphone_account_params_get_routes_addresses(accountParams) != NULL) forKey:@"account_outbound_proxy_preference"];
			[self setBool:linphone_account_is_avpf_enabled(account) forKey:@"account_avpf_preference"];
			[self setBool:linphone_account_params_get_register_enabled(accountParams) forKey:@"account_is_enabled_preference"];
			[self setBool:(linphone_core_get_default_account(LC) == account)
				   forKey:@"account_is_default_preference"];

			const LinphoneAuthInfo *ai = linphone_core_find_auth_info(
				LC, NULL, [self stringForKey:@"account_mandatory_username_preference"].UTF8String,
				[self stringForKey:@"account_mandatory_domain_preference"].UTF8String);
			if (ai) {
				[self setCString:linphone_auth_info_get_userid(ai) forKey:@"account_userid_preference"];
				[self setCString:linphone_auth_info_get_passwd(ai) forKey:@"account_mandatory_password_preference"];
				// hidden but useful if provisioned
				[self setCString:linphone_auth_info_get_ha1(ai) forKey:@"ha1_preference"];
				[self setCString:linphone_auth_info_get_algorithm(ai) forKey:@"ha1_algo_preference"];
			}

			int idx = (int)bctbx_list_index(linphone_core_get_account_list(LC), account);
			[self setInteger:idx forKey:@"current_proxy_config_preference"];

			int expires = linphone_account_params_get_expires(accountParams);
			[self setInteger:expires forKey:@"account_expire_preference"];

			LinphoneNatPolicy *policy = linphone_account_params_get_nat_policy(accountParams);
			if (policy) {
				[self setBool:linphone_nat_policy_ice_enabled(policy) forKey:@"account_ice_preference"];
				[self setCString:linphone_nat_policy_get_stun_server(policy) forKey:@"account_stun_preference"];
			}
		}

		// call section
		{
			const char *dial_prefix = linphone_account_params_get_international_prefix(accountParams);
			[self setCString:dial_prefix forKey:@"account_prefix_preference"];
			BOOL dial_escape_plus = linphone_account_params_get_dial_escape_plus_enabled(accountParams);
			[self setBool:dial_escape_plus forKey:@"account_substitute_+_by_00_preference"];
		}
	}
}

- (void)transformLinphoneCoreToKeys {
	LinphoneManager *lm = LinphoneManager.instance;

	// root section
	{
		const bctbx_list_t *accounts = linphone_core_get_account_list(LC);
		size_t count = bctbx_list_size(accounts);
		for (size_t i = 1; i <= count; i++, accounts = accounts->next) {
			NSString *key = [NSString stringWithFormat:@"menu_account_%lu", i];
			LinphoneAccount *account = (LinphoneAccount *)accounts->data;
			[self setCString:linphone_address_get_username(linphone_account_params_get_identity_address(linphone_account_get_params(account)))
					  forKey:key];
		}

		[self setBool:linphone_core_video_display_enabled(LC) forKey:@"enable_video_preference"];
		[self setBool:[LinphoneManager.instance lpConfigBoolForKey:@"auto_answer"]
			   forKey:@"enable_auto_answer_preference"];
		[self setBool:[lm lpConfigBoolForKey:@"account_mandatory_advanced_preference"]
			   forKey:@"account_mandatory_advanced_preference"];
	}

	// account section
	{ [self transformAccountToKeys:nil]; }

	// audio section
	{
		[self transformCodecsToKeys:linphone_core_get_audio_codecs(LC)];
		[self setFloat:linphone_core_get_playback_gain_db(LC) forKey:@"playback_gain_preference"];
		[self setFloat:linphone_core_get_mic_gain_db(LC) forKey:@"microphone_gain_preference"];
		[self setInteger:[lm lpConfigIntForKey:@"codec_bitrate_limit"
									 inSection:@"audio"
								   withDefault:kLinphoneAudioVbrCodecDefaultBitrate]
				  forKey:@"audio_codec_bitrate_limit_preference"];
		[self setInteger:[lm lpConfigIntForKey:@"voiceproc_preference" withDefault:1] forKey:@"voiceproc_preference"];
		[self setInteger:[lm lpConfigIntForKey:@"eq_active" inSection:@"sound" withDefault:0] forKey:@"eq_active"];
	}

	// video section
	{
		[self transformCodecsToKeys:linphone_core_get_video_codecs(LC)];

		const LinphoneVideoPolicy *pol;
		pol = linphone_core_get_video_policy(LC);
		[self setBool:(pol->automatically_initiate) forKey:@"start_video_preference"];
		[self setBool:(pol->automatically_accept) forKey:@"accept_video_preference"];
		[self setBool:linphone_core_self_view_enabled(LC) forKey:@"self_video_preference"];
		BOOL previewEnabled = [lm lpConfigBoolForKey:@"preview_preference" withDefault:YES];
		[self setBool:IPAD && previewEnabled forKey:@"preview_preference"];

		const char *preset = linphone_core_get_video_preset(LC);
		[self setCString:preset ? preset : "default" forKey:@"video_preset_preference"];
		MSVideoSize vsize = linphone_core_get_preferred_video_size(LC);
		int index;
		if ((vsize.width == MS_VIDEO_SIZE_720P_W) && (vsize.height == MS_VIDEO_SIZE_720P_H)) {
			index = 0;
		} else if ((vsize.width == MS_VIDEO_SIZE_VGA_W) && (vsize.height == MS_VIDEO_SIZE_VGA_H)) {
			index = 1;
		} else {
			index = 2;
		}
		[self setInteger:index forKey:@"video_preferred_size_preference"];
		[self setInteger:linphone_core_get_preferred_framerate(LC) forKey:@"video_preferred_fps_preference"];
		[self setInteger:linphone_core_get_download_bandwidth(LC) forKey:@"download_bandwidth_preference"];
	}

	// call section
	{
		[self setBool:linphone_core_get_use_info_for_dtmf(LC) forKey:@"sipinfo_dtmf_preference"];
		[self setBool:linphone_core_get_use_rfc2833_for_dtmf(LC) forKey:@"rfc_dtmf_preference"];

		[self setInteger:linphone_core_get_inc_timeout(LC) forKey:@"incoming_call_timeout_preference"];
		[self setInteger:linphone_core_get_in_call_timeout(LC) forKey:@"in_call_timeout_preference"];

		[self setBool:[lm lpConfigBoolForKey:@"repeat_call_notification"]
			   forKey:@"repeat_call_notification_preference"];
		[self setBool:linphone_core_is_media_encryption_mandatory(LC) forKey:@"media_encrption_mandatory_preference"];
		[self setBool:[lm lpConfigBoolForKey:@"pref_accept_early_media"]
			   forKey:@"pref_accept_early_media_preference"];
	}

	// chat section
	{
		[self setCString:linphone_core_get_file_transfer_server(LC) forKey:@"file_transfer_server_url_preference"];
        int maxSize = linphone_core_get_max_size_for_auto_download_incoming_files(LC);
        [self setObject:maxSize==0 ? @"Always" : (maxSize==-1 ? @"Nerver" : @"Customize") forKey:@"auto_download_mode"];
        [self setInteger:maxSize forKey:@"auto_download_incoming_files_max_size"];
		[self setBool:[VFSUtil vfsEnabledWithGroupName:kLinphoneMsgNotificationAppGroupId] forKey:@"vfs_enabled_mode"];
		[self setBool:[lm lpConfigBoolForKey:@"auto_write_to_gallery_preference" withDefault:YES] forKey:@"auto_write_to_gallery_mode"];
		[self setBool:[lm lpConfigBoolForKey:@"ephemeral_feature" withDefault:NO] forKey:@"ephemeral_feature"];
	}

	// network section
	{
		LinphoneNatPolicy *np = linphone_core_get_nat_policy(LC);
		[self setBool:[lm lpConfigBoolForKey:@"edge_opt_preference" withDefault:NO] forKey:@"edge_opt_preference"];
		[self setBool:[lm lpConfigBoolForKey:@"wifi_only_preference" withDefault:NO] forKey:@"wifi_only_preference"];
		[self setCString:linphone_nat_policy_get_stun_server(np) forKey:@"stun_preference"];
		[self setBool:linphone_nat_policy_ice_enabled(np) forKey:@"ice_preference"];
		[self setBool:linphone_nat_policy_turn_enabled(np) forKey:@"turn_preference"];
		
		[self setCString:linphone_nat_policy_get_stun_server_username(np)
				  forKey:@"turn_username"];

		int random_port_preference = [lm lpConfigIntForKey:@"random_port_preference" withDefault:1];
		[self setInteger:random_port_preference forKey:@"random_port_preference"];
		int port = [lm lpConfigIntForKey:@"port_preference" withDefault:5060];
		[self setInteger:port forKey:@"port_preference"];
		{
			int minPort, maxPort;
			linphone_core_get_audio_port_range(LC, &minPort, &maxPort);
			if (minPort != maxPort)
				[self setObject:[NSString stringWithFormat:@"%d-%d", minPort, maxPort] forKey:@"audio_port_preference"];
			else
				[self setObject:[NSString stringWithFormat:@"%d", minPort] forKey:@"audio_port_preference"];
		}
		{
			int minPort, maxPort;
			linphone_core_get_video_port_range(LC, &minPort, &maxPort);
			if (minPort != maxPort)
				[self setObject:[NSString stringWithFormat:@"%d-%d", minPort, maxPort] forKey:@"video_port_preference"];
			else
				[self setObject:[NSString stringWithFormat:@"%d", minPort] forKey:@"video_port_preference"];
		}
		[self setBool:linphone_core_ipv6_enabled(LC) forKey:@"use_ipv6"];
		LinphoneMediaEncryption menc = linphone_core_get_media_encryption(LC);
		const char *val;
		switch (menc) {
			case LinphoneMediaEncryptionSRTP:
				val = "SRTP";
				break;
			case LinphoneMediaEncryptionZRTP:
				val = "ZRTP";
				break;
			case LinphoneMediaEncryptionDTLS:
				val = "DTLS";
				break;
			case LinphoneMediaEncryptionNone:
				val = "None";
				break;
		}
		[self setCString:val forKey:@"media_encryption_preference"];
		[self setInteger:linphone_core_get_upload_bandwidth(LC) forKey:@"upload_bandwidth_preference"];
		[self setInteger:linphone_core_get_download_bandwidth(LC) forKey:@"download_bandwidth_preference"];
		[self setBool:linphone_core_adaptive_rate_control_enabled(LC) forKey:@"adaptive_rate_control_preference"];
	}

	// tunnel section
	if (linphone_core_tunnel_available()) {
		LinphoneTunnel *tunnel = linphone_core_get_tunnel(LC);
		[self setObject:[lm lpConfigStringForKey:@"tunnel_mode_preference" withDefault:@"off"]
				 forKey:@"tunnel_mode_preference"];
		const MSList *configs = linphone_tunnel_get_servers(tunnel);
		if (configs != NULL) {
			LinphoneTunnelConfig *ltc = (LinphoneTunnelConfig *)configs->data;
			[self setCString:linphone_tunnel_config_get_host(ltc) forKey:@"tunnel_address_preference"];
			[self setInteger:linphone_tunnel_config_get_port(ltc) forKey:@"tunnel_port_preference"];
		} else {
			[self setCString:"" forKey:@"tunnel_address_preference"];
			[self setInteger:443 forKey:@"tunnel_port_preference"];
		}
	}

	// advanced section
	{
		[self setObject:[lm lpConfigStringForKey:@"debugenable_preference"] forKey:@"debugenable_preference"];
		[self setBool:ANIMATED forKey:@"animations_preference"];
		[self setBool:[lm lpConfigBoolForKey:@"backgroundmode_preference"] forKey:@"backgroundmode_preference"];
		[self setBool:[lm lpConfigBoolForKey:@"start_at_boot_preference"] forKey:@"start_at_boot_preference"];
		[self setBool:[lm lpConfigBoolForKey:@"autoanswer_notif_preference"] forKey:@"autoanswer_notif_preference"];
		[self setBool:[lm lpConfigBoolForKey:@"show_msg_in_notif" withDefault:YES] forKey:@"show_msg_in_notif"];
		[self setBool:[lm lpConfigBoolForKey:@"use_rls_presence" withDefault:YES] forKey:@"use_rls_presence"];
		[self setBool:[lm lpConfigBoolForKey:@"enable_first_login_view_preference"]
			   forKey:@"enable_first_login_view_preference"];
		LinphoneAddress *parsed = linphone_core_get_primary_contact_parsed(LC);
		if (parsed != NULL) {
			[self setCString:linphone_address_get_display_name(parsed) forKey:@"primary_displayname_preference"];
			[self setCString:linphone_address_get_username(parsed) forKey:@"primary_username_preference"];
			linphone_address_unref(parsed);
		}
	}

	changedDict = [[NSMutableDictionary alloc] init];

	// Post event
	NSDictionary *eventDic = [NSDictionary dictionaryWithObject:self forKey:@"settings"];
	[NSNotificationCenter.defaultCenter postNotificationName:kLinphoneLogsUpdate object:self userInfo:eventDic];
}

- (void)alertAccountError:(NSString *)error {
	UIAlertController *errView = [UIAlertController alertControllerWithTitle:NSLocalizedString(@"Error", nil)
																	 message:error
															  preferredStyle:UIAlertControllerStyleAlert];
	
	UIAlertAction* defaultAction = [UIAlertAction actionWithTitle:NSLocalizedString(@"OK", nil)
															style:UIAlertActionStyleDefault
														  handler:^(UIAlertAction * action) {}];
	
	[errView addAction:defaultAction];
	[PhoneMainView.instance presentViewController:errView animated:YES completion:nil];
}

- (void)synchronizeAccounts {
	LOGI(@"Account changed, synchronizing.");
	LinphoneManager *lm = LinphoneManager.instance;
	LinphoneAccount *account = NULL;
	LinphoneAccountParams *newAccountParams = NULL;
	NSString *error = nil;

	int port_preference = [self integerForKey:@"port_preference"];

	BOOL random_port_preference = [self boolForKey:@"random_port_preference"];
	[lm lpConfigSetInt:random_port_preference forKey:@"random_port_preference"];
	if (random_port_preference) {
		port_preference = -1;
	}

	LCSipTransports transportValue = {port_preference, port_preference, -1, -1};

	// will also update the sip_*_port section of the config
	if (linphone_core_set_sip_transports(LC, &transportValue)) {
		LOGE(@"cannot set transport");
	}

	port_preference = linphone_core_get_sip_port(LC);
	[self setInteger:port_preference forKey:@"port_preference"]; // Update back preference

	BOOL enable_ipv6 = [self boolForKey:@"use_ipv6"];
	[lm lpConfigSetBool:enable_ipv6 forKey:@"use_ipv6" inSection:@"sip"];
	LOGD(@"%@ IPV6", enable_ipv6 ? @"ENABLING" : @"DISABLING");
	linphone_core_enable_ipv6(LC, enable_ipv6);

	// configure sip account

	// mandatory parameters
	NSString *username = [self stringForKey:@"account_mandatory_username_preference"];
	NSString *displayName = [self stringForKey:@"account_display_name_preference"];
	NSString *userID = [self stringForKey:@"account_userid_preference"];
	NSString *domain = [self stringForKey:@"account_mandatory_domain_preference"];
	NSString *transport = [self stringForKey:@"account_transport_preference"];
	NSString *accountHa1 = [self stringForKey:@"ha1_preference"];
	NSString *accountPassword = [self stringForKey:@"account_mandatory_password_preference"];
	NSString *accountAlgoPreference = [self stringForKey:@"ha1_algo_preference"];
	BOOL isOutboundProxy = [self boolForKey:@"account_outbound_proxy_preference"];
	BOOL use_avpf = [self boolForKey:@"account_avpf_preference"];
	BOOL is_default = [self boolForKey:@"account_is_default_preference"];
	BOOL is_enabled = [self boolForKey:@"account_is_enabled_preference"];
	BOOL use_ice = [self boolForKey:@"account_ice_preference"];
	NSString *stun_preference = [self stringForKey:@"account_stun_preference"];

	if (username && [username length] > 0 && domain && [domain length] > 0) {
		int expire = [self integerForKey:@"account_expire_preference"];
		BOOL pushnotification = [self boolForKey:@"account_pushnotification_preference"];
		NSString *prefix = [self stringForKey:@"account_prefix_preference"];
		NSString *proxyAddress = [self stringForKey:@"account_proxy_preference"];

		if ((!proxyAddress || [proxyAddress length] < 1) && domain) {
			proxyAddress = domain;
		}

		if (![proxyAddress hasPrefix:@"sip:"] && ![proxyAddress hasPrefix:@"sips:"]) {
			proxyAddress = [NSString stringWithFormat:@"sip:%@", proxyAddress];
		}

		LinphoneAddress *proxy_addr = linphone_core_interpret_url(LC, proxyAddress.UTF8String);

		if (proxy_addr) {
			LinphoneTransportType type = LinphoneTransportUdp;
			if ([transport isEqualToString:@"tcp"])
				type = LinphoneTransportTcp;
			else if ([transport isEqualToString:@"tls"])
				type = LinphoneTransportTls;

			linphone_address_set_transport(proxy_addr, type);
		}

		account = bctbx_list_nth_data(linphone_core_get_account_list(LC),
									   [self integerForKey:@"current_proxy_config_preference"]);
		
		// if account was deleted, it is not present anymore
		if (account == NULL)
			goto bad_proxy;


		LinphoneAddress *linphoneAddress = linphone_core_interpret_url(LC, "sip:user@domain.com");
		linphone_address_set_username(linphoneAddress, username.UTF8String);
		if ([LinphoneManager.instance lpConfigBoolForKey:@"use_phone_number" inSection:@"assistant"]) {
			char *user = linphone_account_normalize_phone_number(account, username.UTF8String);
			if (user) {
				linphone_address_set_username(linphoneAddress, user);
				ms_free(user);
			}
		}
		linphone_address_set_domain(linphoneAddress, [domain UTF8String]);
		linphone_address_set_display_name(linphoneAddress, (displayName.length ? displayName.UTF8String : NULL));
		const char *password = [accountPassword UTF8String];
		const char *ha1 = [accountHa1 UTF8String];

		newAccountParams = linphone_account_params_clone(linphone_account_get_params(account));
		
		if (linphone_account_params_set_identity_address(newAccountParams, linphoneAddress) == -1) {
			error = NSLocalizedString(@"Invalid username or domain", nil);
			goto bad_proxy;
		}
		// use proxy as route if outbound_proxy is enabled
		if (linphone_account_params_set_server_address(newAccountParams, proxy_addr) == -1) {
			error = NSLocalizedString(@"Invalid proxy address", nil);
			goto bad_proxy;
		}
		if (linphone_account_params_set_routes_addresses(newAccountParams, isOutboundProxy ? bctbx_list_new((void*)proxy_addr) : NULL) == -1) {
			error = NSLocalizedString(@"Invalid route", nil);
			goto bad_proxy;
		}

		LinphoneNatPolicy *policy = linphone_account_params_get_nat_policy(newAccountParams) ?: linphone_core_create_nat_policy(LC);
		linphone_nat_policy_enable_stun(policy, use_ice); // We always use STUN with ICE
		linphone_nat_policy_enable_ice(policy, use_ice);
		linphone_nat_policy_set_stun_server(policy, stun_preference.UTF8String);
		linphone_account_params_set_nat_policy(newAccountParams, policy);

		if ([prefix length] > 0) {
			linphone_account_params_set_international_prefix(newAccountParams, [prefix UTF8String]);
		}

		if ([self objectForKey:@"account_substitute_+_by_00_preference"]) {
			bool substitute_plus_by_00 = [self boolForKey:@"account_substitute_+_by_00_preference"];
			linphone_account_params_set_dial_escape_plus_enabled(newAccountParams, substitute_plus_by_00);
		}

		// use empty string "" instead of NULL to avoid being overwritten by default proxy config values
		linphone_account_params_set_push_notification_allowed(newAccountParams, pushnotification);
		linphone_account_params_set_remote_push_notification_allowed(newAccountParams, pushnotification);

		linphone_account_params_set_register_enabled(newAccountParams, is_enabled);
		linphone_account_params_set_avpf_mode(newAccountParams, use_avpf);
		linphone_account_params_set_expires(newAccountParams, expire);
		
		linphone_account_set_params(account, newAccountParams);
		linphone_account_params_unref(newAccountParams);
		if (is_default) {
			linphone_core_set_default_account(LC, account);
		} else if (linphone_core_get_default_account(LC) == account) {
			linphone_core_set_default_account(LC, NULL);
		}

		LinphoneAuthInfo *proxyAi = (LinphoneAuthInfo *)linphone_account_find_auth_info(account);
		char *realm;
		if (proxyAi) {
			realm = ms_strdup(linphone_auth_info_get_realm(proxyAi));
		} else {
			realm = NULL;
		}

		// modify auth info only after finishing editting the proxy config, so that
		// UNREGISTER succeed
		if (proxyAi) {
			linphone_core_remove_auth_info(LC, proxyAi);
		}
		if (strcmp(password,"") == 0) {
			password = NULL;
		}

		char *identity = linphone_address_as_string(linphoneAddress);
		LinphoneAddress *from = linphone_core_interpret_url(LC, identity);
		ms_free(identity);
		if (from) {
			const char *userid_str = (userID != nil) ? [userID UTF8String] : NULL;
			LinphoneAuthInfo *info;
			if (password) {
				info = linphone_auth_info_new(linphone_address_get_username(from), userid_str, password, NULL,
											  linphone_account_params_get_realm(newAccountParams),
											  linphone_account_params_get_domain(newAccountParams));
			} else {
				info = linphone_auth_info_new_for_algorithm(linphone_address_get_username(from)
															, userid_str
															, NULL
															, ha1
															, realm ? realm : linphone_account_params_get_realm(newAccountParams),
											  linphone_account_params_get_domain(newAccountParams), [accountAlgoPreference UTF8String]);
			}

			linphone_address_unref(from);
			linphone_core_add_auth_info(LC, info);
			linphone_auth_info_destroy(info);
			ms_free(realm);
		}
		
	bad_proxy:
		if (linphoneAddress)
			linphone_address_destroy(linphoneAddress);
			
		// in case of error, show an alert to the user
		if (error != nil) {
			if (newAccountParams != NULL) { // If we get here, then we're also sure that Account != NULL
				
				linphone_account_params_unref(newAccountParams);
			}
			UIAlertController *errView = [UIAlertController alertControllerWithTitle:NSLocalizedString(@"Error", nil)
																			 message:error
																	  preferredStyle:UIAlertControllerStyleAlert];
			
			UIAlertAction* defaultAction = [UIAlertAction actionWithTitle:NSLocalizedString(@"OK", nil)
																	style:UIAlertActionStyleDefault
																  handler:^(UIAlertAction * action) {}];
			
			[errView addAction:defaultAction];
			[PhoneMainView.instance presentViewController:errView animated:YES completion:nil];
		}
		
	}
	// reload address book to prepend proxy config domain to contacts' phone number
	[[LinphoneManager.instance fastAddressBook] fetchContactsInBackGroundThread];
}

- (void)synchronizeCodecs:(const MSList *)codecs {
	PayloadType *pt;
	const MSList *elem;

	for (elem = codecs; elem != NULL; elem = elem->next) {
		pt = (PayloadType *)elem->data;
		NSString *pref = [LinphoneManager getPreferenceForCodec:pt->mime_type withRate:pt->clock_rate];
		linphone_core_enable_payload_type(LC, pt, [self boolForKey:pref]);
	}
}

- (BOOL)synchronize {
	@try {
		LinphoneManager *lm = LinphoneManager.instance;

		// root section
		BOOL account_changed = NO;
		for (NSString *key in self->changedDict) {
			if ([key hasPrefix:@"account_"] && [self valueChangedForKey:key]) {
				account_changed = YES;
				break;
			}
		}
		account_changed |= [self valueChangedForKey:@"port_preference"];
		account_changed |= [self valueChangedForKey:@"random_port_preference"];
		account_changed |= [self valueChangedForKey:@"use_ipv6"];

		if (account_changed)
			[self synchronizeAccounts];

		bool enableVideo = [self boolForKey:@"enable_video_preference"];
		linphone_core_enable_video_capture(LC, enableVideo);
		linphone_core_enable_video_display(LC, enableVideo);

		bool enableAutoAnswer = [self boolForKey:@"enable_auto_answer_preference"];
		[LinphoneManager.instance lpConfigSetBool:enableAutoAnswer forKey:@"auto_answer"];

		// audio section
		[self synchronizeCodecs:linphone_core_get_audio_codecs(LC)];

		float playback_gain = [self floatForKey:@"playback_gain_preference"];
		linphone_core_set_playback_gain_db(LC, playback_gain);

		float mic_gain = [self floatForKey:@"microphone_gain_preference"];
		linphone_core_set_mic_gain_db(LC, mic_gain);

		[lm lpConfigSetInt:[self integerForKey:@"audio_codec_bitrate_limit_preference"]
					forKey:@"codec_bitrate_limit"
				 inSection:@"audio"];

		BOOL voice_processing = [self boolForKey:@"voiceproc_preference"];
		[lm lpConfigSetInt:voice_processing forKey:@"voiceproc_preference"];

		BOOL equalizer = [self boolForKey:@"eq_active"];
		[lm lpConfigSetBool:equalizer forKey:@"eq_active" inSection:@"sound"];

		[LinphoneManager.instance configureVbrCodecs];

		NSString *au_device = @"AU: Audio Unit Receiver";
		if (!voice_processing)
			au_device = @"AU: Audio Unit NoVoiceProc";

		linphone_core_set_capture_device(LC, [au_device UTF8String]);
		linphone_core_set_playback_device(LC, [au_device UTF8String]);

		// video section
		[self synchronizeCodecs:linphone_core_get_video_codecs(LC)];

		LinphoneVideoPolicy policy;
		policy.automatically_initiate = [self boolForKey:@"start_video_preference"];
		policy.automatically_accept = [self boolForKey:@"accept_video_preference"];
		linphone_core_set_video_policy(LC, &policy);
		linphone_core_enable_self_view(LC, [self boolForKey:@"self_video_preference"]);
		BOOL preview_preference = IPAD && [self boolForKey:@"preview_preference"];
		[lm lpConfigSetInt:preview_preference forKey:@"preview_preference"];

		NSString *videoPreset = [self stringForKey:@"video_preset_preference"];
		linphone_core_set_video_preset(LC, [videoPreset UTF8String]);
		MSVideoSize vsize;
		switch ([self integerForKey:@"video_preferred_size_preference"]) {
			case 0:
				MS_VIDEO_SIZE_ASSIGN(vsize, 720P);
				break;
			case 1:
				MS_VIDEO_SIZE_ASSIGN(vsize, VGA);
				break;
			case 2:
			default:
				MS_VIDEO_SIZE_ASSIGN(vsize, QVGA);
				break;
		}
		linphone_core_set_preferred_video_size(LC, vsize);
		if (![videoPreset isEqualToString:@"custom"]) {
			[self setInteger:0 forKey:@"video_preferred_fps_preference"];
			[self setInteger:0 forKey:@"download_bandwidth_preference"];
		}
		linphone_core_set_preferred_framerate(LC, [self integerForKey:@"video_preferred_fps_preference"]);
		linphone_core_set_download_bandwidth(LC, [self integerForKey:@"download_bandwidth_preference"]);
		linphone_core_set_upload_bandwidth(LC, [self integerForKey:@"download_bandwidth_preference"]);

		// call section
		linphone_core_set_use_rfc2833_for_dtmf(LC, [self boolForKey:@"rfc_dtmf_preference"]);
		linphone_core_set_use_info_for_dtmf(LC, [self boolForKey:@"sipinfo_dtmf_preference"]);
		linphone_core_set_inc_timeout(LC, [self integerForKey:@"incoming_call_timeout_preference"]);
		linphone_core_set_in_call_timeout(LC, [self integerForKey:@"in_call_timeout_preference"]);
		[lm lpConfigSetString:[self stringForKey:@"voice_mail_uri_preference"] forKey:@"voice_mail_uri"];
		[lm lpConfigSetBool:[self boolForKey:@"repeat_call_notification_preference"] forKey:@"repeat_call_notification"];
		[lm lpConfigSetBool:[self boolForKey:@"pref_accept_early_media_preference"] forKey:@"pref_accept_early_media"];
		linphone_core_set_media_encryption_mandatory(LC, [self boolForKey:@"media_encrption_mandatory_preference"]);

		linphone_core_set_file_transfer_server(LC, [self stringForKey:@"file_transfer_server_url_preference"].UTF8String);
        int maxSize;
        NSString *downloadMode = [self stringForKey:@"auto_download_mode"];
        if ([downloadMode isEqualToString:@"Never"]) {
            maxSize = -1;
        } else if ([downloadMode isEqualToString:@"Always"]) {
            maxSize = 0;
        } else {
            maxSize = [[self stringForKey:@"auto_download_incoming_files_max_size"] intValue];
        }
        linphone_core_set_max_size_for_auto_download_incoming_files(LC, maxSize);
        [lm lpConfigSetString:[self stringForKey:@"auto_download_mode"] forKey:@"auto_download_mode"];
		BOOL vfsPrefEnabled = [self boolForKey:@"vfs_enabled_mode"] || [VFSUtil vfsEnabledWithGroupName:kLinphoneMsgNotificationAppGroupId];
		if (vfsPrefEnabled && ![VFSUtil vfsEnabledWithGroupName:kLinphoneMsgNotificationAppGroupId]) {
			if (TARGET_IPHONE_SIMULATOR) {
				LOGW(@"[VFS] Can not active for simulators.");
				[VFSUtil setVfsEnabbledWithEnabled:false groupName:kLinphoneMsgNotificationAppGroupId];
				[self setBool:FALSE forKey:@"vfs_enabled_mode"];
			} else if (![VFSUtil activateVFSForFirstTime:true]) {
				[VFSUtil log:@"[VFS] Error unable to activate ! Warning disabling VFS enabled preference." :OS_LOG_TYPE_ERROR];
				[VFSUtil setVfsEnabbledWithEnabled:false groupName:kLinphoneMsgNotificationAppGroupId];
				[self setBool:FALSE forKey:@"vfs_enabled_mode"];
			} else {
				[VFSUtil setVfsEnabbledWithEnabled:true groupName:kLinphoneMsgNotificationAppGroupId];
				[self setBool:TRUE forKey:@"vfs_enabled_mode"];
			}
		}
		[lm lpConfigSetBool:[self boolForKey:@"auto_write_to_gallery_mode"] forKey:@"auto_write_to_gallery_preference"];
		[lm lpConfigSetBool:[self boolForKey:@"ephemeral_feature"] forKey:@"ephemeral_feature"];

		// network section
		BOOL edgeOpt = [self boolForKey:@"edge_opt_preference"];
		[lm lpConfigSetInt:edgeOpt forKey:@"edge_opt_preference"];

		BOOL wifiOnly = [self boolForKey:@"wifi_only_preference"];
		[lm lpConfigSetInt:wifiOnly forKey:@"wifi_only_preference"];

		LinphoneNatPolicy *LNP = linphone_core_get_nat_policy(LC);
		
		BOOL ice_preference = [self boolForKey:@"ice_preference"];
		linphone_nat_policy_enable_ice(LNP, ice_preference);
		
		linphone_nat_policy_enable_turn(LNP, [self boolForKey:@"turn_preference"]);
		
		NSString *stun_server = [self stringForKey:@"stun_preference"];
		if ([stun_server length] > 0) {
			linphone_nat_policy_set_stun_server(LNP, [stun_server UTF8String]);
			linphone_nat_policy_enable_stun(LNP, ice_preference); /*we always use STUN with ICE*/
			NSString *turn_username = [self stringForKey:@"turn_username"];
			NSString *turn_password = [self stringForKey:@"turn_password"];

			if ([turn_username length] > 0) {
				const LinphoneAuthInfo *turnAuthInfo = nil;
				if ([turn_password length] > 0){
					turnAuthInfo = linphone_auth_info_new([turn_username UTF8String], NULL, [turn_password UTF8String], NULL, NULL, NULL);
					linphone_core_add_auth_info(LC, turnAuthInfo);
				} else
					turnAuthInfo = linphone_core_find_auth_info(LC, NULL, [turn_username UTF8String], NULL);

				linphone_nat_policy_set_stun_server_username(LNP, [turn_username UTF8String]);
			}
		} else {
			linphone_nat_policy_enable_stun(LNP, FALSE);
			linphone_nat_policy_set_stun_server(LNP, NULL);
		}
		linphone_core_set_nat_policy(LC, LNP);

		NSString *audio_port_preference = [self stringForKey:@"audio_port_preference"];
		int audioMinPort, audioMaxPort;
		[LinphoneCoreSettingsStore parsePortRange:audio_port_preference minPort:&audioMinPort maxPort:&audioMaxPort];
		linphone_core_set_audio_port_range(LC, audioMinPort, audioMaxPort);

		NSString *video_port_preference = [self stringForKey:@"video_port_preference"];
		int videoMinPort, videoMaxPort;
		[LinphoneCoreSettingsStore parsePortRange:video_port_preference minPort:&videoMinPort maxPort:&videoMaxPort];
		linphone_core_set_video_port_range(LC, videoMinPort, videoMaxPort);

		NSString *menc = [self stringForKey:@"media_encryption_preference"];
		if (menc && [menc compare:@"SRTP"] == NSOrderedSame)
			linphone_core_set_media_encryption(LC, LinphoneMediaEncryptionSRTP);
		else if (menc && [menc compare:@"ZRTP"] == NSOrderedSame)
			linphone_core_set_media_encryption(LC, LinphoneMediaEncryptionZRTP);
		else if (menc && [menc compare:@"DTLS"] == NSOrderedSame)
			linphone_core_set_media_encryption(LC, LinphoneMediaEncryptionDTLS);
		else
			linphone_core_set_media_encryption(LC, LinphoneMediaEncryptionNone);

		linphone_core_enable_adaptive_rate_control(LC, [self boolForKey:@"adaptive_rate_control_preference"]);

		// tunnel section
		if (linphone_core_tunnel_available()) {
			NSString *lTunnelPrefMode = [self stringForKey:@"tunnel_mode_preference"];
			NSString *lTunnelPrefAddress = [self stringForKey:@"tunnel_address_preference"];
			int lTunnelPrefPort = [self integerForKey:@"tunnel_port_preference"];
			LinphoneTunnel *tunnel = linphone_core_get_tunnel(LC);
			LinphoneTunnelMode mode = LinphoneTunnelModeDisable;
			int lTunnelPort = 443;
			if (lTunnelPrefPort)
				lTunnelPort = lTunnelPrefPort;

			linphone_tunnel_clean_servers(tunnel);
			if (lTunnelPrefAddress && [lTunnelPrefAddress length]) {
				LinphoneTunnelConfig *ltc = linphone_tunnel_config_new();
				linphone_tunnel_config_set_host(ltc, [lTunnelPrefAddress UTF8String]);
				linphone_tunnel_config_set_port(ltc, lTunnelPort);
				linphone_tunnel_add_server(tunnel, ltc);

				if ([lTunnelPrefMode isEqualToString:@"off"])
					mode = LinphoneTunnelModeDisable;
				else if ([lTunnelPrefMode isEqualToString:@"on"])
					mode = LinphoneTunnelModeEnable;
				else if ([lTunnelPrefMode isEqualToString:@"auto"])
					mode = LinphoneTunnelModeAuto;
				else
					LOGE(@"Unexpected tunnel mode [%s]", [lTunnelPrefMode UTF8String]);
			}

			[lm lpConfigSetString:lTunnelPrefMode forKey:@"tunnel_mode_preference"];
			linphone_tunnel_set_mode(tunnel, mode);
		}

		// advanced section
		BOOL animations = [self boolForKey:@"animations_preference"];
		[lm lpConfigSetInt:animations forKey:@"animations_preference"];

		UIDevice *device = [UIDevice currentDevice];
		BOOL backgroundSupported = [device respondsToSelector:@selector(isMultitaskingSupported)] && [device isMultitaskingSupported];
		BOOL isbackgroundModeEnabled = backgroundSupported && [self boolForKey:@"backgroundmode_preference"];
		[lm lpConfigSetInt:isbackgroundModeEnabled forKey:@"backgroundmode_preference"];
		[lm lpConfigSetInt:[self integerForKey:@"start_at_boot_preference"] forKey:@"start_at_boot_preference"];
		[lm lpConfigSetInt:[self integerForKey:@"autoanswer_notif_preference"] forKey:@"autoanswer_notif_preference"];
		[lm lpConfigSetInt:[self integerForKey:@"show_msg_in_notif"] forKey:@"show_msg_in_notif"];

		if ([self integerForKey:@"use_rls_presence"]) {
			[self setInteger:0 forKey:@"use_rls_presence"];
			NSString *rls_uri = [lm lpConfigStringForKey:@"rls_uri" inSection:@"sip" withDefault:@"sips:rls@sip.linphone.org"];
			LinphoneAddress *rls_addr = linphone_address_new(rls_uri.UTF8String);
			const char *rls_domain = linphone_address_get_domain(rls_addr);
			const MSList *accounts = linphone_core_get_account_list(LC);
			if (!accounts) // Enable it if no proxy config for first launch of app
				[self setInteger:1 forKey:@"use_rls_presence"];
			else {
				while (accounts) {
					const char *proxy_domain = linphone_account_params_get_domain(linphone_account_get_params(accounts->data));
					if (strcmp(rls_domain, proxy_domain) == 0) {
						[self setInteger:1 forKey:@"use_rls_presence"];
						break;
					}
					accounts = accounts->next;
				}
			}
			linphone_address_unref(rls_addr);
		}

		[lm lpConfigSetInt:[self integerForKey:@"use_rls_presence"] forKey:@"use_rls_presence"];
		linphone_core_enable_friend_list_subscription(LC, [self integerForKey:@"use_rls_presence"]);

		BOOL firstloginview = [self boolForKey:@"enable_first_login_view_preference"];
		[lm lpConfigSetInt:firstloginview forKey:@"enable_first_login_view_preference"];

		NSString *displayname = [self stringForKey:@"primary_displayname_preference"];
		NSString *username = [self stringForKey:@"primary_username_preference"];
		LinphoneAddress *parsed = linphone_core_get_primary_contact_parsed(LC);
		if (parsed != NULL) {
			linphone_address_set_display_name(parsed, [displayname UTF8String]);
			linphone_address_set_username(parsed, [username UTF8String]);
			char *contact = linphone_address_as_string(parsed);
			linphone_core_set_primary_contact(LC, contact);
			ms_free(contact);
			linphone_address_destroy(parsed);
		}
		[lm lpConfigSetInt:[self integerForKey:@"account_mandatory_advanced_preference"] forKey:@"account_mandatory_advanced_preference"];

		changedDict = [[NSMutableDictionary alloc] init];

		// Post event
		NSDictionary *eventDic = [NSDictionary dictionaryWithObject:self forKey:@"settings"];
		[NSNotificationCenter.defaultCenter postNotificationName:kLinphoneSettingsUpdate object:self userInfo:eventDic];

		return YES;
	} @catch (NSException *exception) {
		// may happen when application is terminated, since we are destroying the core
		if ([exception.name isEqualToString:@"LinphoneCoreException"]) {
			LOGE(@"Core already destroyed, settings not synchronized");
			return NO;
		}
		LOGE(@"Uncaught exception : %@", exception.description);
		abort();
	}
	return NO;
}

- (void)removeAccount {
	LinphoneAccount *account = bctbx_list_nth_data(linphone_core_get_account_list(LC),
													  [self integerForKey:@"current_proxy_config_preference"]);
	
	const MSList *lists = linphone_core_get_friends_lists(LC);
	while (lists) {
		linphone_friend_list_enable_subscriptions(lists->data, FALSE);
		linphone_friend_list_update_subscriptions(lists->data);
		lists = lists->next;
	}
	BOOL isDefault = (linphone_core_get_default_account(LC) == account);

	const LinphoneAuthInfo *ai = linphone_account_find_auth_info(account);
	linphone_core_remove_account(LC, account);
	if (ai) {
		// Friend list unsubscription above is not instantanous, so give a bit of a time margin before finishing the removal of the auth info
		dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(5 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
			linphone_core_remove_auth_info(LC, ai);
		});
	}
	[self setInteger:-1 forKey:@"current_proxy_config_preference"];

	if (isDefault) {
		// if we removed the default proxy config, set another one instead
		if (linphone_core_get_account_list(LC) != NULL) {
			linphone_core_set_default_account(LC, (LinphoneAccount *)(linphone_core_get_account_list(LC)->data));
		}
	}
	[self transformLinphoneCoreToKeys];
}
@end