using System;

using System.Linq;

using System.Collections.Generic;

using System.Net.Http;

using System.Threading.Tasks;

using System.Text;

using Newtonsoft.Json;

using Newtonsoft.Json.Linq;

using NETCoreSync.Exceptions;

namespace NETCoreSync

{

public class SyncClient

{

private readonly string synchronizationId;

private readonly SyncEngine syncEngine;

private readonly string serverUrl;

private readonly Dictionary<string, string> httpHeaders;

public enum SynchronizationMethodEnum

{

PushThenPull,

PullThenPush

}

public SyncClient(string synchronizationId, SyncEngine syncEngine, string serverUrl)

: this(synchronizationId, syncEngine, serverUrl, null)

{

}

public SyncClient(string synchronizationId, SyncEngine syncEngine, string serverUrl, Dictionary<string, string> httpHeaders)

{

this.synchronizationId = synchronizationId ?? throw new NullReferenceException(nameof(synchronizationId));

this.syncEngine = syncEngine ?? throw new NullReferenceException(nameof(syncEngine));

this.serverUrl = serverUrl ?? throw new NullReferenceException(nameof(serverUrl));

this.httpHeaders = httpHeaders;

}

public async Task<SyncResult> SynchronizeAsync(SynchronizationMethodEnum synchronizationMethod = SynchronizationMethodEnum.PushThenPull, Dictionary<string, object> customInfo = null)

{

SyncResult syncResult = new SyncResult();

try

{

syncResult.Log.Add($"=== Synchronize Started ===");

if (syncEngine.SyncConfiguration.TimeStampStrategy == SyncConfiguration.TimeStampStrategyEnum.GlobalTimeStamp)

{

await SynchronizeGlobalTimeStamp(synchronizationMethod, customInfo, syncResult);

}

else if (syncEngine.SyncConfiguration.TimeStampStrategy == SyncConfiguration.TimeStampStrategyEnum.DatabaseTimeStamp)

{

await SynchronizeDatabaseTimeStamp(synchronizationMethod, customInfo, syncResult);

}

else

{

throw new NotImplementedException(syncEngine.SyncConfiguration.TimeStampStrategy.ToString());

}

syncResult.Log.Add($"=== Synchronize Finished ===");

}

catch (Exception e)

{

syncResult.ErrorMessage = e.Message;

syncResult.Log.Add($"=== Error: {e.Message} ===");

}

return syncResult;

}

private async Task SynchronizeDatabaseTimeStamp(SynchronizationMethodEnum synchronizationMethod, Dictionary<string, object> customInfo, SyncResult syncResult)

{

if (synchronizationMethod == SynchronizationMethodEnum.PushThenPull)

{

await SynchronizeDatabaseTimeStampOneWay(true, customInfo, syncResult);

await SynchronizeDatabaseTimeStampOneWay(false, customInfo, syncResult);

}

else if (synchronizationMethod == SynchronizationMethodEnum.PullThenPush)

{

await SynchronizeDatabaseTimeStampOneWay(false, customInfo, syncResult);

await SynchronizeDatabaseTimeStampOneWay(true, customInfo, syncResult);

}

else

{

throw new NotImplementedException(synchronizationMethod.ToString());

}

}

private async Task SynchronizeDatabaseTimeStampOneWay(bool runOnClient, Dictionary<string, object> customInfo, SyncResult syncResult)

{

string localName = null;

string remoteName = null;

SyncEngine.PayloadAction payloadAction = SyncEngine.PayloadAction.Synchronize;

if (runOnClient)

{

localName = "Client";

remoteName = "Server";

payloadAction = SyncEngine.PayloadAction.Synchronize;

}

else

{

localName = "Server";

remoteName = "Client";

payloadAction = SyncEngine.PayloadAction.SynhronizeReverse;

}

syncResult.Log.Add($"=== {localName} Get Knowledge (As Local Knowledge) ===");

SyncEngine.GetKnowledgeParameter localGetKnowledgeParameter = new SyncEngine.GetKnowledgeParameter(

SyncEngine.PayloadAction.Knowledge,

synchronizationId,

customInfo);

if (runOnClient) localGetKnowledgeParameter.Log = syncResult.Log;

SyncEngine.GetKnowledgeResult localGetKnowledgeResult = null;

if (runOnClient)

{

try

{

syncEngine.GetKnowledge(localGetKnowledgeParameter, ref localGetKnowledgeResult);

}

catch (Exception)

{

throw;

}

}

else

{

(string localGetKnowledgeErrMsg, JObject jObjectLocalGetKnowledgeResult) = await ExecuteOnServer(localGetKnowledgeParameter.GetCompressed(), syncResult);

if (jObjectLocalGetKnowledgeResult != null)

{

localGetKnowledgeResult = SyncEngine.GetKnowledgeResult.FromPayload(jObjectLocalGetKnowledgeResult);

}

if (!string.IsNullOrEmpty(localGetKnowledgeErrMsg)) throw new Exception(localGetKnowledgeErrMsg);

}

syncResult.Log.Add($"=== {remoteName} Get Knowledge (As Remote Knowledge) ===");

SyncEngine.GetKnowledgeParameter remoteGetKnowledgeParameter = new SyncEngine.GetKnowledgeParameter(

SyncEngine.PayloadAction.Knowledge,

synchronizationId,

customInfo);

if (!runOnClient) remoteGetKnowledgeParameter.Log = syncResult.Log;

SyncEngine.GetKnowledgeResult remoteGetKnowledgeResult = null;

if (runOnClient)

{

(string remoteGetKnowledgeErrMsg, JObject jObjectRemoteGetKnowledgeResult) = await ExecuteOnServer(remoteGetKnowledgeParameter.GetCompressed(), syncResult);

if (jObjectRemoteGetKnowledgeResult != null)

{

remoteGetKnowledgeResult = SyncEngine.GetKnowledgeResult.FromPayload(jObjectRemoteGetKnowledgeResult);

}

if (!string.IsNullOrEmpty(remoteGetKnowledgeErrMsg)) throw new Exception(remoteGetKnowledgeErrMsg);

}

else

{

try

{

syncEngine.GetKnowledge(remoteGetKnowledgeParameter, ref remoteGetKnowledgeResult);

}

catch (Exception)

{

throw;

}

}

syncResult.Log.Add($"=== {localName} Get Changes based on {remoteName} Knowledge ===");

SyncEngine.GetChangesByKnowledgeParameter getChangesByKnowledgeParameter = new SyncEngine.GetChangesByKnowledgeParameter(

payloadAction,

synchronizationId,

customInfo);

if (runOnClient) getChangesByKnowledgeParameter.Log = syncResult.Log;

getChangesByKnowledgeParameter.LocalKnowledgeInfos = localGetKnowledgeResult.KnowledgeInfos;

getChangesByKnowledgeParameter.RemoteKnowledgeInfos = remoteGetKnowledgeResult.KnowledgeInfos;

SyncEngine.GetChangesByKnowledgeResult getChangesByKnowledgeResult = null;

if (runOnClient)

{

try

{

syncEngine.GetChangesByKnowledge(getChangesByKnowledgeParameter, ref getChangesByKnowledgeResult);

}

catch (Exception)

{

throw;

}

finally

{

if (getChangesByKnowledgeResult != null)

{

syncResult.ClientLog.SentChanges.AddRange(getChangesByKnowledgeResult.LogChanges);

}

}

}

else

{

(string getChangesByKnowledgeErrMsg, JObject jObjectGetChangesByKnowledgeResult) = await ExecuteOnServer(getChangesByKnowledgeParameter.GetCompressed(), syncResult);

if (jObjectGetChangesByKnowledgeResult != null)

{

getChangesByKnowledgeResult = SyncEngine.GetChangesByKnowledgeResult.FromPayload(jObjectGetChangesByKnowledgeResult);

syncResult.ServerLog.SentChanges.AddRange(getChangesByKnowledgeResult.LogChanges);

}

if (!string.IsNullOrEmpty(getChangesByKnowledgeErrMsg)) throw new Exception(getChangesByKnowledgeErrMsg);

}

syncResult.Log.Add($"=== {remoteName} Apply Changes ===");

SyncEngine.ApplyChangesByKnowledgeParameter applyChangesByKnowledgeParameter = new SyncEngine.ApplyChangesByKnowledgeParameter(

payloadAction,

synchronizationId,

customInfo);

if (!runOnClient) applyChangesByKnowledgeParameter.Log = syncResult.Log;

applyChangesByKnowledgeParameter.Changes = getChangesByKnowledgeResult.Changes;

applyChangesByKnowledgeParameter.SourceDatabaseInstanceId = localGetKnowledgeResult.KnowledgeInfos.Where(w => w.IsLocal).First().DatabaseInstanceId;

applyChangesByKnowledgeParameter.DestinationDatabaseInstanceId = remoteGetKnowledgeResult.KnowledgeInfos.Where(w => w.IsLocal).First().DatabaseInstanceId;

SyncEngine.ApplyChangesByKnowledgeResult applyChangesByKnowledgeResult = null;

if (runOnClient)

{

(string applyChangesByKnowledgeErrMsg, JObject jObjectApplyChangesByKnowledgeResult) = await ExecuteOnServer(applyChangesByKnowledgeParameter.GetCompressed(), syncResult);

if (jObjectApplyChangesByKnowledgeResult != null)

{

applyChangesByKnowledgeResult = SyncEngine.ApplyChangesByKnowledgeResult.FromPayload(jObjectApplyChangesByKnowledgeResult);

syncResult.ServerLog.AppliedChanges.Inserts.AddRange(applyChangesByKnowledgeResult.Inserts);

syncResult.ServerLog.AppliedChanges.Updates.AddRange(applyChangesByKnowledgeResult.Updates);

syncResult.ServerLog.AppliedChanges.Deletes.AddRange(applyChangesByKnowledgeResult.Deletes);

syncResult.ServerLog.AppliedChanges.Conflicts.AddRange(applyChangesByKnowledgeResult.Conflicts);

}

if (!string.IsNullOrEmpty(applyChangesByKnowledgeErrMsg)) throw new Exception(applyChangesByKnowledgeErrMsg);

}

else

{

try

{

syncEngine.ApplyChangesByKnowledge(applyChangesByKnowledgeParameter, ref applyChangesByKnowledgeResult);

}

catch (Exception)

{

throw;

}

finally

{

if (applyChangesByKnowledgeResult != null)

{

syncResult.ClientLog.AppliedChanges.Inserts.AddRange(applyChangesByKnowledgeResult.Inserts);

syncResult.ClientLog.AppliedChanges.Updates.AddRange(applyChangesByKnowledgeResult.Updates);

syncResult.ClientLog.AppliedChanges.Deletes.AddRange(applyChangesByKnowledgeResult.Deletes);

syncResult.ClientLog.AppliedChanges.Conflicts.AddRange(applyChangesByKnowledgeResult.Conflicts);

}

}

}

}

private async Task SynchronizeGlobalTimeStamp(SynchronizationMethodEnum synchronizationMethod, Dictionary<string, object> customInfo, SyncResult syncResult)

{

if (synchronizationMethod != SynchronizationMethodEnum.PushThenPull)

{

throw new SyncEngineConstraintException($"{nameof(synchronizationMethod)} other than {SynchronizationMethodEnum.PushThenPull.ToString()} is not supported, because {nameof(SyncConfiguration.TimeStampStrategyEnum.GlobalTimeStamp)} is already using Global DateTime (World Clock) as the time stamp, therefore, performing PushThenPull / PullThenPush will not have different effect (due to the same kind of time stamp being compared)");

}

syncResult.Log.Add("=== Client Get Changes ===");

SyncEngine.GetChangesParameter clientGetChangesParameter = new SyncEngine.GetChangesParameter(

SyncEngine.PayloadAction.Synchronize,

synchronizationId,

customInfo);

clientGetChangesParameter.Log = syncResult.Log;

clientGetChangesParameter.LastSync = syncEngine.InvokeGetClientLastSync();

SyncEngine.GetChangesResult clientGetChangesResult = null;

try

{

syncEngine.GetChanges(clientGetChangesParameter, ref clientGetChangesResult);

}

catch (Exception)

{

throw;

}

finally

{

if (clientGetChangesResult != null)

{

syncResult.ClientLog.SentChanges.AddRange(clientGetChangesResult.LogChanges);

}

}

syncResult.Log.Add("=== Server Apply Changes ===");

SyncEngine.ApplyChangesParameter serverApplyChangesParameter = new SyncEngine.ApplyChangesParameter(

SyncEngine.PayloadAction.Synchronize,

synchronizationId,

customInfo);

serverApplyChangesParameter.Changes = clientGetChangesResult.Changes;

SyncEngine.ApplyChangesResult serverApplyChangesResult = null;

(string serverApplyChangesErrMsg, JObject jObjectServerApplyChangesResult) = await ExecuteOnServer(serverApplyChangesParameter.GetCompressed(), syncResult);

if (jObjectServerApplyChangesResult != null)

{

serverApplyChangesResult = SyncEngine.ApplyChangesResult.FromPayload(jObjectServerApplyChangesResult);

syncResult.ServerLog.AppliedChanges.Inserts.AddRange(serverApplyChangesResult.Inserts);

syncResult.ServerLog.AppliedChanges.Updates.AddRange(serverApplyChangesResult.Updates);

syncResult.ServerLog.AppliedChanges.Deletes.AddRange(serverApplyChangesResult.Deletes);

syncResult.ServerLog.AppliedChanges.Conflicts.AddRange(serverApplyChangesResult.Conflicts);

}

if (!string.IsNullOrEmpty(serverApplyChangesErrMsg)) throw new Exception(serverApplyChangesErrMsg);

syncResult.Log.Add("=== Server Get Changes ===");

SyncEngine.GetChangesParameter serverGetChangesParameter = new SyncEngine.GetChangesParameter(

SyncEngine.PayloadAction.SynhronizeReverse,

synchronizationId,

customInfo);

serverGetChangesParameter.LastSync = clientGetChangesParameter.LastSync;

serverGetChangesParameter.PayloadAppliedIds = serverApplyChangesResult.PayloadAppliedIds;

SyncEngine.GetChangesResult serverGetChangesResult = null;

(string serverGetChangesErrMsg, JObject jObjectServerGetChangesResult) = await ExecuteOnServer(serverGetChangesParameter.GetCompressed(), syncResult);

if (jObjectServerGetChangesResult != null)

{

serverGetChangesResult = SyncEngine.GetChangesResult.FromPayload(jObjectServerGetChangesResult);

syncResult.ServerLog.SentChanges.AddRange(serverGetChangesResult.LogChanges);

}

if (!string.IsNullOrEmpty(serverGetChangesErrMsg)) throw new Exception(serverGetChangesErrMsg);

syncResult.Log.Add("=== Client Apply Changes ===");

SyncEngine.ApplyChangesParameter clientApplyChangesParameter = new SyncEngine.ApplyChangesParameter(

SyncEngine.PayloadAction.Synchronize,

synchronizationId,

customInfo);

clientApplyChangesParameter.Log = syncResult.Log;

clientApplyChangesParameter.Changes = serverGetChangesResult.Changes;

SyncEngine.ApplyChangesResult clientApplyChangesResult = null;

try

{

syncEngine.ApplyChanges(clientApplyChangesParameter, ref clientApplyChangesResult);

}

catch (Exception)

{

throw;

}

finally

{

if (clientApplyChangesResult != null)

{

syncResult.ClientLog.AppliedChanges.Inserts.AddRange(clientApplyChangesResult.Inserts);

syncResult.ClientLog.AppliedChanges.Updates.AddRange(clientApplyChangesResult.Updates);

syncResult.ClientLog.AppliedChanges.Deletes.AddRange(clientApplyChangesResult.Deletes);

syncResult.ClientLog.AppliedChanges.Conflicts.AddRange(clientApplyChangesResult.Conflicts);

}

}

syncResult.Log.Add($"===LastSync from Client Get Changes Parameter: {clientGetChangesParameter.LastSync} ===");

syncResult.Log.Add($"===MaxTimeStamp from Client Get Changes Result: {clientGetChangesResult.MaxTimeStamp} ===");

syncResult.Log.Add($"===MaxTimeStamp from Server Get Changes Result: {serverGetChangesResult.MaxTimeStamp} ===");

long maxLastSync = clientGetChangesParameter.LastSync;

if (clientGetChangesResult.MaxTimeStamp > maxLastSync) maxLastSync = clientGetChangesResult.MaxTimeStamp;

if (serverGetChangesResult.MaxTimeStamp > maxLastSync) maxLastSync = serverGetChangesResult.MaxTimeStamp;

syncResult.Log.Add($"=== LastSync Updated To: {maxLastSync} ===");

syncEngine.SetClientLastSync(maxLastSync);

}

private async Task<(string errorMessage, JObject payload)> ExecuteOnServer(byte[] compressed, SyncResult syncResult)

{

JObject payload = null;

using (var httpClient = new HttpClient())

{

if (httpHeaders != null)

{

httpHeaders.ToList().ForEach(kvp =>

{

if (httpClient.DefaultRequestHeaders.Contains(kvp.Key)) httpClient.DefaultRequestHeaders.Remove(kvp.Key);

httpClient.DefaultRequestHeaders.Add(kvp.Key, kvp.Value);

});

}

using (var multipartFormDataContent = new MultipartFormDataContent())

{

ByteArrayContent byteArrayContent = new ByteArrayContent(compressed);

multipartFormDataContent.Add(byteArrayContent, "files", "compressed.data");

var response = await httpClient.PostAsync(serverUrl, multipartFormDataContent);

if (response.IsSuccessStatusCode)

{

string responseContent = await response.Content.ReadAsStringAsync();

JObject jObjectResponse = null;

try

{

jObjectResponse = JsonConvert.DeserializeObject<JObject>(responseContent);

}

catch (Exception eInner)

{

return ($"Unable to parse Response as JObject: {eInner.Message}. Response: {responseContent}", payload);

}

List<string> serverLog = jObjectResponse["log"].ToObject<List<string>>();

for (int i = 0; i < serverLog.Count; i++)

{

syncResult.Log.Add($"Server -> {serverLog[i]}");

}

if (jObjectResponse.ContainsKey("payload"))

{

byte[] compressedResponse = Convert.FromBase64String(jObjectResponse["payload"].Value<string>());

string jsonResponse = SyncEngine.Decompress(compressedResponse);

payload = JsonConvert.DeserializeObject<JObject>(jsonResponse);

}

if (jObjectResponse.ContainsKey("errorMessage"))

{

return ($"ServerMessage: {jObjectResponse["errorMessage"].Value<string>()}", payload);

}

return (null, payload);

}

else

{

return ($"Response StatusCode: {response.StatusCode}, ReasonPhrase: {response.ReasonPhrase}", payload);

}

}

}

}

}

}