using System;

using System.Collections.Generic;

using System.ComponentModel.DataAnnotations;

using System.Threading;

using System.Threading.Tasks;

namespace SourceGit.ViewModels

{

public class Pull : Popup

{

public List<Models.Remote> Remotes => _repo.Remotes;

public Models.Branch Current { get; }

public bool HasSpecifiedRemoteBranch

{

get;

private set;

}

public Models.Remote SelectedRemote

{

get => _selectedRemote;

set

{

if (SetProperty(ref _selectedRemote, value))

PostRemoteSelected();

}

}

public List<Models.Branch> RemoteBranches

{

get => _remoteBranches;

private set => SetProperty(ref _remoteBranches, value);

}

[Required(ErrorMessage = "Remote branch to pull is required!!!")]

public Models.Branch SelectedBranch

{

get => _selectedBranch;

set => SetProperty(ref _selectedBranch, value, true);

}

public bool HasLocalChanges

{

get => _repo.LocalChangesCount > 0;

}

public Models.DealWithLocalChanges DealWithLocalChanges

{

get => _dealWithLocalChanges;

set => SetProperty(ref _dealWithLocalChanges, value);

}

public bool UseRebase

{

get => _useRebase;

set => SetProperty(ref _useRebase, value);

}

public override bool HasDefaultOptions

{

get => true;

}

public Pull(Repository repo, Models.Branch specifiedRemoteBranch)

{

_repo = repo;

Current = repo.CurrentBranch;

CanTerminate = true;

_dealWithLocalChanges = repo.UIStates.DealWithLocalChangesOnPull ?? GetPreferredDealWithLocalChanges();

_useRebase = repo.UIStates.PreferRebaseInsteadOfMerge;

if (specifiedRemoteBranch != null)

{

_selectedRemote = repo.Remotes.Find(x => x.Name == specifiedRemoteBranch.Remote);

_selectedBranch = specifiedRemoteBranch;

var branches = new List<Models.Branch>();

foreach (var branch in _repo.Branches)

{

if (branch.Remote == specifiedRemoteBranch.Remote)

branches.Add(branch);

}

_remoteBranches = branches;

HasSpecifiedRemoteBranch = true;

}

else

{

Models.Remote autoSelectedRemote = null;

if (!string.IsNullOrEmpty(Current.Upstream))

{

var remoteNameEndIdx = Current.Upstream.IndexOf('/', 13);

if (remoteNameEndIdx > 0)

{

var remoteName = Current.Upstream.Substring(13, remoteNameEndIdx - 13);

autoSelectedRemote = _repo.Remotes.Find(x => x.Name == remoteName);

}

}

if (autoSelectedRemote == null)

{

Models.Remote remote = null;

if (!string.IsNullOrEmpty(_repo.Settings.DefaultRemote))

remote = _repo.Remotes.Find(x => x.Name == _repo.Settings.DefaultRemote);

_selectedRemote = remote ?? _repo.Remotes[0];

}

else

{

_selectedRemote = autoSelectedRemote;

}

PostRemoteSelected();

HasSpecifiedRemoteBranch = false;

}

}

public override void SaveOptionsAsDefault()

{

_repo.UIStates.DealWithLocalChangesOnPull = _dealWithLocalChanges;

_repo.UIStates.PreferRebaseInsteadOfMerge = _useRebase;

_repo.UIStates.Save();

}

public override void ResetDefaultOptions()

{

var defaults = new Models.RepositoryUIStates();

_repo.UIStates.DealWithLocalChangesOnPull = defaults.DealWithLocalChangesOnPull;

_repo.UIStates.PreferRebaseInsteadOfMerge = defaults.PreferRebaseInsteadOfMerge;

_repo.UIStates.Save();

DealWithLocalChanges = GetPreferredDealWithLocalChanges();

UseRebase = defaults.PreferRebaseInsteadOfMerge;

}

public override async Task<bool> Sure()

{

using var lockWatcher = _repo.LockWatcher();

var log = _repo.CreateLog("Pull");

Use(log);

_cancellation = new CancellationTokenSource();

var token = _cancellation.Token;

var changes = await new Commands.CountLocalChanges(_repo.FullPath, false).GetResultAsync();

var needPopStash = false;

if (changes > 0)

{

if (DealWithLocalChanges == Models.DealWithLocalChanges.DoNothing)

{

// Do nothing, just let the pull command fail and show the error to user

}

else if (DealWithLocalChanges == Models.DealWithLocalChanges.StashAndReapply)

{

var succ = await new Commands.Stash(_repo.FullPath).Use(log).PushAsync("PULL_AUTO_STASH", false);

if (!succ)

{

log.Complete();

_repo.MarkWorkingCopyDirtyManually();

_cancellation = null;

return false;

}

needPopStash = true;

}

else

{

await Commands.Discard.AllAsync(_repo.FullPath, true, false, false, log);

}

}

bool rs = false;

if (!token.IsCancellationRequested)

{

var target = _selectedBranch;

if (!string.IsNullOrEmpty(Current.Upstream) && target.FullName.Equals(Current.Upstream, StringComparison.Ordinal))

target = null;

rs = await new Commands.Pull(

_repo.FullPath,

_selectedRemote,

target,

UseRebase).WithCancellation(token).Use(log).ExecAsync();

if (rs)

{

await _repo.AutoUpdateSubmodulesAsync(log);

if (needPopStash)

await new Commands.Stash(_repo.FullPath).Use(log).PopAsync("stash@{0}");

}

}

log.Complete();

if (_repo.SelectedViewIndex == 0)

{

var head = await new Commands.QueryRevisionByRefName(_repo.FullPath, "HEAD").GetResultAsync();

_repo.NavigateToCommit(head, true);

}

_cancellation = null;

return rs;

}

public override void Terminate()

{

// Just fire cancel event and UI will auto wait the `Sure` complete

var _ = _cancellation?.CancelAsync();

}

private static Models.DealWithLocalChanges GetPreferredDealWithLocalChanges()

{

return Preferences.Instance.UseStashAndReapplyByDefault ?

Models.DealWithLocalChanges.StashAndReapply :

Models.DealWithLocalChanges.DoNothing;

}

private void PostRemoteSelected()

{

var remoteName = _selectedRemote.Name;

var branches = new List<Models.Branch>();

foreach (var branch in _repo.Branches)

{

if (!branch.IsLocal && branch.Remote.Equals(remoteName, StringComparison.Ordinal))

branches.Add(branch);

}

Models.Branch selected = null;

if (!string.IsNullOrEmpty(Current.Upstream))

selected = branches.Find(x => x.FullName.Equals(Current.Upstream, StringComparison.Ordinal));

if (selected == null)

selected = branches.Find(x => x.Name.Equals(Current.Name, StringComparison.Ordinal));

RemoteBranches = branches;

SelectedBranch = selected;

}

private readonly Repository _repo = null;

private Models.Remote _selectedRemote = null;

private List<Models.Branch> _remoteBranches = null;

private Models.Branch _selectedBranch = null;

private Models.DealWithLocalChanges _dealWithLocalChanges = Models.DealWithLocalChanges.DoNothing;

private bool _useRebase = true;

private CancellationTokenSource _cancellation = null;

}

}