/usr/local/share/dotnet/dotnet

<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
    // 1.
    <PropertyGroup>
        <RuntimeIdentifier>osx</RuntimeIdentifier>
        <NuGetRuntimeIdentifier>osx</NuGetRuntimeIdentifier>
        <AutoGenerateBindingRedirects>true</AutoGenerateBindingRedirects>
    </PropertyGroup>
    ....
    

using Foundation;
using UIKit;
using System;

//1
using DittoSDK;

namespace Tasks
{
    // The UIApplicationDelegate for the application. This class is responsible for launching the
    // User Interface of the application, as well as listening (and optionally responding) to application events from iOS.
    [Register ("AppDelegate")]
    public class AppDelegate : UIResponder, IUIApplicationDelegate {

        [Export("window")]
        public UIWindow Window { get; set; }

        //2
        internal Ditto ditto;

        [Export ("application:didFinishLaunchingWithOptions:")]
        public bool FinishedLaunching (UIApplication application, NSDictionary launchOptions)
        {

            //3
            NSFileManager fileManager = new NSFileManager();
            NSUrl url = fileManager.GetUrl(NSSearchPathDirectory.DocumentDirectory, NSSearchPathDomain.User, null, true, out NSError error);
            if (error != null)
            {
                Console.WriteLine($"Error creating Documents directory: {error.LocalizedDescription}");
            }
            url = url.Append("ditto", true);

            fileManager.CreateDirectory(url, true, null, out error);
            if (error != null)
            {
                Console.WriteLine($"Error creating ditto directory: {error.LocalizedDescription}");
            }

            string workingDir = url.Path;

            //4
            DittoIdentity identity = DittoIdentity.OnlinePlayground(appID: "REPLACE_ME", token: "REPLACE_ME"
, false, workingDir: workingDir);

            ditto = new Ditto(identity, workingDir);

            //5
            var transportConfig = new DittoTransportConfig();
            transportConfig.EnableAllPeerToPeer();
            ditto.TransportConfig = transportConfig;

            //6
            ditto.StartSync();

            return true;
        }

        // UISceneSession Lifecycle

        [Export ("application:configurationForConnectingSceneSession:options:")]
        public UISceneConfiguration GetConfiguration (UIApplication application, UISceneSession connectingSceneSession, UISceneConnectionOptions options)
        {
            // Called when a new scene session is being created.
            // Use this method to select a configuration to create the new scene with.
            return UISceneConfiguration.Create ("Default Configuration", connectingSceneSession.Role);
        }

        [Export ("application:didDiscardSceneSessions:")]
        public void DidDiscardSceneSessions (UIApplication application, NSSet<UISceneSession> sceneSessions)
        {
            // Called when the user discards a scene session.
            // If any sessions were discarded while the application was not running, this will be called shortly after `FinishedLaunching`.
            // Use this method to release any resources that were specific to the discarded scenes, as they will not return.
        }
    }
}

// 1
using DittoSDK;

namespace Tasks
{
    public class Task
    {
        // 2
        public string _id;
        public string body;
        public bool isCompleted;

        // 3
        public Task(DittoDocument document)
        {
            this._id = document["_id"].StringValue;
            this.body = document["body"].StringValue;
            this.isCompleted = document["isCompleted"].BooleanValue;
        }
    }
}

using System;
using UIKit;
// Remember to import Ditto
using DittoSDK;
using System.Collections.Generic;

namespace Tasks
{
    public partial class TasksTableViewController : UITableViewController
    {
        // These hold references to Ditto for easy access
        private DittoLiveQuery liveQuery;
        private DittoSubscription subscription;
        private Ditto ditto
        {
            get
            {
                var appDelegate = (AppDelegate)UIApplication.SharedApplication.Delegate;
                return appDelegate.ditto;
            }
        }
        private DittoCollection collection
        {
            get
            {
                return this.ditto.Store.Collection("tasks");
            }
        }

        // List that will contain all the tasks
        List<Task> tasks = new List<Task>();

        // data source for the TasksTableViewController
        private TasksTableSource tasksTableSource = new TasksTableSource();

        public TasksTableViewController(IntPtr handle) : base(handle)
        {
        }

        public override void ViewWillAppear(bool animated)
        {
            base.ViewWillAppear(animated);

            TableView.Source = tasksTableSource;
        }

        public override void ViewDidLoad()
        {
            base.ViewDidLoad();
            setupTaskList();
        }

        // Sets up Live Query for syncing
        public void setupTaskList()
        {
            subscription = ditto.Store["tasks"].Find("!isDeleted").Subscribe()
            liveQuery = ditto.Store["tasks"].Find("!isDeleted").ObserveLocal((docs, _event) =>
            {
                tasks = docs.ConvertAll(d => new Task(d));
                tasksTableSource.updateTasks(tasks);

                InvokeOnMainThread(() =>
                {
                    TableView.ReloadData();
                });

            });
            
            ditto.Store["tasks"].Find("isDeleted == true").Evict();
        }

        // Creates a new task
        partial void didClickAddTask(UIBarButtonItem sender)
        {
            // Create an alert
            var alertControl = UIAlertController.Create(
                title: "Add New Task",
                message: null,
                preferredStyle: UIAlertControllerStyle.Alert);

            // Add a text field to the alert for the new task text
            alertControl.AddTextField(configurationHandler: (UITextField obj) => obj.Placeholder = "Enter Task");

            alertControl.AddAction(UIAlertAction.Create(title: "Cancel", style: UIAlertActionStyle.Cancel, handler: null));

            // Add a "OK" button to the alert.
            alertControl.AddAction(UIAlertAction.Create(title: "OK", style: UIAlertActionStyle.Default, alarm => addTask(alertControl.TextFields[0].Text)));

            // Present the alert to the user
            PresentViewController(alertControl, animated: true, null);
        }

        public void addTask(string text)
        {
            var dict = new Dictionary<string, object>
            {
                {"body", text},
                {"isCompleted", false}
            };

            var docId = this.collection.Upsert(dict);
        }
    }
}

// These hold references to Ditto for easy access
private DittoLiveQuery liveQuery;
private Ditto ditto
{
    get
    {
        var appDelegate = (AppDelegate)UIApplication.SharedApplication.Delegate;
        return appDelegate.ditto;
    }
}
private DittoCollection collection
{
    get
    {
        return this.ditto.Store.Collection("tasks");
    }
}

// List that will contain all the tasks
List<Task> tasks = new List<Task>();

// data source for the TasksTableViewController
private TasksTableSource tasksTableSource = new TasksTableSource();

public TasksTableViewController(IntPtr handle) : base(handle)
{
}

public override void ViewWillAppear(bool animated)
{
    base.ViewWillAppear(animated);

    TableView.Source = tasksTableSource;
}

public override void ViewDidLoad()
{
    base.ViewDidLoad();
    setupTaskList();
}

// Sets up Live Query for syncing
public void setupTaskList()
{
    liveQuery = ditto.Store["tasks"].Find("!isDeleted").ObserveLocal((docs, _event) =>
    {
        tasks = docs.ConvertAll(d => new Task(d));

        // We will implement this later
        tasksTableSource.updateTasks(tasks);

        InvokeOnMainThread(() =>
        {
            TableView.ReloadData();
        });

    });
}

public override void ViewDidLoad()
{
    base.ViewDidLoad();
    setupTaskList();
}

// Sets up Live Query for syncing
public void setupTaskList()
{
    liveQuery = ditto.Store["tasks"].Find("!isDeleted").ObserveLocal((docs, _event) =>
    {
        tasks = docs.ConvertAll(d => new Task(d));

        // We will implement this later
        tasksTableSource.updateTasks(tasks);

        InvokeOnMainThread(() =>
        {
            TableView.ReloadData();
        });

    });
}

// Triggered when add button is pressed
partial void didClickAddTask(UIBarButtonItem sender)
{
    // Create an alert
    var alertControl = UIAlertController.Create(
        title: "Add New Task",
        message: null,
        preferredStyle: UIAlertControllerStyle.Alert);

    // Add a text field to the alert for the new task text
    alertControl.AddTextField(configurationHandler: (UITextField obj) => obj.Placeholder = "Enter Task");

    alertControl.AddAction(UIAlertAction.Create(title: "Cancel", style: UIAlertActionStyle.Cancel, handler: null));

    // Add an "OK" button to the alert.
    alertControl.AddAction(UIAlertAction.Create(title: "OK", style: UIAlertActionStyle.Default, alarm => addTask(alertControl.TextFields[0].Text)));

    // Present the alert to the user
    PresentViewController(alertControl, animated: true, null);
}

public void addTask(string text)
{

    var dict = new Dictionary<string, object>
    {
        {"body", text},
        {"isCompleted", false},
        {"isDeleted", false}
    };

    // Adds the new task to the ditto collection
    var docId = this.collection.Upsert(dict);
}

using System;
using Foundation;
using UIKit;

namespace Tasks
{
    public class TaskTableSource : UITableViewSource
    {
        public TaskTableSource()
        {
        }

        public override UITableViewCell GetCell(UITableView tableView, NSIndexPath indexPath)
        {
            throw new NotImplementedException();
        }

        public override nint RowsInSection(UITableView tableview, nint section)
        {
            throw new NotImplementedException();
        }
    }
}

public class TaskTableSource : UITableViewSource
{
    Task[] tasks;
    NSString cellIdentifier = new NSString("taskCell");

    private DittoCollection collection
    {
        get
        {
            return this.ditto.Store.Collection("tasks");
        }
    }

    private Ditto ditto
    {
        get
        {
            var appDelegate = (AppDelegate)UIApplication.SharedApplication.Delegate;
            return appDelegate.ditto;
        }
    }
    public TaskTableSource()
    {
    }

    public override UITableViewCell GetCell(UITableView tableView, NSIndexPath indexPath)
    {
        throw new NotImplementedException();
    }

    public override nint RowsInSection(UITableView tableview, nint section)
    {
        throw new NotImplementedException();
    }
}

public override nint RowsInSection(UITableView tableview, nint section)
{
    if (this.tasks == null)
    {
        return 0;
    }
    return tasks.Length;
}

public override UITableViewCell GetCell(UITableView tableView, NSIndexPath indexPath)
{
    // 1
    UITableViewCell cell = tableView.DequeueReusableCell(cellIdentifier);
    if (cell == null)
    {
        cell = new UITableViewCell(UITableViewCellStyle.Default, cellIdentifier);
    }

    Task task = tasks[indexPath.Row];

    // 2
    cell.TextLabel.Text = task.body;
    var taskComplete = task.isCompleted;

    //Checks whether the tasks has been completed or not
    if (taskComplete)
    {
        cell.Accessory = UITableViewCellAccessory.Checkmark;
    }
    else
    {
        cell.Accessory = UITableViewCellAccessory.None;
    }

    // 3
    var tapGesture = new UITapGestureRecognizer();
    tapGesture.AddTarget(() =>
    {
        if (taskComplete)
        {
            collection.FindById(task._id).Update(mutableDoc =>
                mutableDoc["isCompleted"].Set(false)
            );
        }
        else
        {
            collection.FindById(task._id).Update(mutableDoc =>
                mutableDoc["isCompleted"].Set(true)
            );
        }
    });
    cell.AddGestureRecognizer(tapGesture);

    return cell;
}

public void updateTasks(List<Task> tasks)
{
    this.tasks = tasks.ToArray();
}

public override void CommitEditingStyle(UITableView tableView, UITableViewCellEditingStyle editingStyle, Foundation.NSIndexPath indexPath)
{
    switch (editingStyle)
    {
        case UITableViewCellEditingStyle.Delete:

            var task = tasks[indexPath.Row];
            collection.FindById(task._id).Update((mutableDoc) => {
                if (mutableDoc == null) return;
                mutableDoc["isDeleted"].Set(true);
            });

            break;
        case UITableViewCellEditingStyle.None:
            Console.WriteLine("CommitEditingStyle:None called");
            break;
    }
}