#nullable enable

using System;

using System.Collections.Generic;

using System.Threading.Tasks;

using NUnit.Framework;

​

public static class BankSample

{

    public static BankDbContext Database { get; } = new BankDbContext();

    public static async Task Main()

    {

        await new BankSampleTests().RunTests();

        var owner = new Owner(new Guid());

        var checkingAccount = await SetupAccount(owner, BankAccountType.Checking, 325);

        var savingsAccount = await SetupAccount(owner, BankAccountType.Checking, 100);

        Console.WriteLine(checkingAccount != null && savingsAccount != null

                          ? "Accounts set up successfuly"

                          : "Error setting up accounts");

    }

​

    private static async Task<IBankAccount> SetupAccount(Owner owner, BankAccountType accountType, double initialDeposit)

    {

        if(owner == null){

            throw new ArgumentNullException(nameof(owner));

        }

        if(initialDeposit < 0){

            throw new ArgumentException("initialDeposit {initialDeposit} is less than 0");

        }

        try{

            BankAccount account = new BankAccount(new Guid(), owner.Id, BankAccountType.Checking);

            if(initialDeposit > 0){

                await account.DepositAsync(initialDeposit); 

            }

            return account;

        }

        catch(Exception e){

            Console.WriteLine($"Failed to create account with deposit {initialDeposit}. {e.StackTrace}");

        }

​

        return null;

    }

}

​

public class BankAccount : IBankAccount

{

    public BankAccount(Guid id, Guid ownerId, BankAccountType accountType, double initialBalance = 0)

    {

        if(initialBalance < 0){

            throw new ArgumentException(nameof(initialBalance), "Amount must be greater than or equal to zero.");

        }

        this.Id = id;

        this.OwnerId = ownerId;

        this.AccountType = accountType;

        this.Balance = initialBalance;

    }

​

    public async Task<ITransaction> DepositAsync(double amount) 

    {

        if (amount <= 0)

        {

            throw new ArgumentException(nameof(amount), "Amount must be greater than zero.");

        }

        var transaction = new Transaction(this.OwnerId, this.Id, amount);

        await BankSample.Database.Transactions.Add(transaction);

        await BankSample.Database.SaveChangesAsync();

        this.Balance += amount;

        return transaction;

    }

    public async Task<ITransaction> WithdrawAsync(double amount) 

    {

        if (amount <= 0)

        {

            throw new ArgumentException(nameof(amount), "Amount must be greater than zero.");

        }

​

        if (!this.AllowOverdraft && this.Balance + - amount < 0)

        {

            throw new OverdraftException(this.Balance - amount);

        }

​

        var transaction = new Transaction(this.OwnerId, this.OwnerId, amount);

        await BankSample.Database.Transactions.Add(transaction);

        this.Balance -= amount;

        return transaction;

    }

​

    public Guid Id { get; }

​

    public Guid OwnerId { get; }

​

    public double Balance { get; private set; }

​

    public double InterestRate { get; private set; }

​

    public bool IsOverdrawn => this.Balance < 0;

    public bool AllowOverdraft { get; set; }

​

    public BankAccountType AccountType { get; }

}

​

public class Transaction : ITransaction

{

    public Transaction(Guid ownerId, Guid accountId, double amount)

    {

        this.OwnerId = ownerId;

        this.AccountId = accountId;

        this.Amount = amount;

    }

​

    public Guid Id { get; }

​

    public Guid OwnerId { get; }

​

    public Guid AccountId { get; }

​

    public DateTime Time { get; }

​

    public double Amount { get; }

}

​

public class Owner

{

    public Owner(Guid id)

    {

        this.Id = id;

    }

​

    public Guid Id { get; }

​

    public string? FirstName { get; set; }

​

    public string? LastName { get; set; }

}

​

public class OverdraftException : Exception

{

    public OverdraftException(double overdraftAmount)

    {

        this.OverdraftAmount = overdraftAmount;

    }

​

    public double OverdraftAmount { get; private set; }

}

​

public enum BankAccountType

{

    Checking = 0,

    Savings = 1,

}

​

public class BankDbContext

{

    public BankDbContext()

    {

        this.BankAccounts = new DbSet<IBankAccount>();

        this.Transactions = new DbSet<ITransaction>();

        this.Owners = new DbSet<IOwner>();

    }

​

    public DbSet<IBankAccount> BankAccounts { get; private set; }

​

    public DbSet<ITransaction> Transactions { get; private set; }

​

    public DbSet<IOwner> Owners { get; private set; }

​

    public async Task SaveChangesAsync()

    {

        await Task.Delay(1000);

        // Can throw exceptions, for example if DB is locked

    }

}

​

public class DbSet<TEntity>

{

    private readonly IList<TEntity> entities = new List<TEntity>();

    public async Task Add(TEntity entity)

    {

        await Task.Run(() => this.entities.Add(entity));

    }

}

​

/**************** Interfaces ****************/

public interface IBankAccount

{

    Guid Id { get; }

​

    Guid OwnerId { get; }

​

    double Balance { get; }

​

    double InterestRate { get; }

​

    BankAccountType AccountType { get; }

​

    bool IsOverdrawn { get; }

​

    bool AllowOverdraft { get; set; }

​

    Task<ITransaction> DepositAsync(double amount);

    Task<ITransaction> WithdrawAsync(double amount);

}

​

public interface ITransaction

{

    Guid Id { get; }

​

    Guid OwnerId { get; }

​

    Guid AccountId { get; }

​

    DateTime Time { get; }

​

    double Amount { get; }

}

​

public interface IOwner

{

    Guid Id { get; }

​

    string FirstName { get; set; }

​

    string LastName { get; set; }

}

​

/**************** Tests ****************/

public class BankSampleTests

{

    public async Task RunTests()

    {

        await new BankAccountTests().RunTests();

    }

}

​

public class BankAccountTests

{

    public async Task RunTests()

    {

        this.Initial_Balance_Test();

        this.Deposit_Invalid_Test();

        await this.Deposit_Balance_Test();

        await this.Deposit_Transaction_Test();

    }

​

    public void Initial_Balance_Test()

    {

        // Create a new account, balance should be 0

        var account = new BankAccount(new Guid(), new Guid(), BankAccountType.Savings); 

        Assert.IsTrue(account.Balance == 0, "Balance is 0");

    }

​

    public void Deposit_Invalid_Test()

    {

        // Create a new account, deposit an invalid amount, should throw exception

        try{

            var account = new BankAccount(new Guid(), new Guid(), BankAccountType.Savings, -1); 

            Assert.IsTrue(false, "ArgumentException is expected.");

        }

        catch(ArgumentException){

            Assert.IsTrue(true, "ArgumentException is caught.");

        }

    }

​

    public async Task Deposit_Balance_Test()

    {

        // Create a new account, with a deposit of 500, balance should be 500

        var account = new BankAccount(new Guid(), new Guid(), BankAccountType.Savings); 

        var depositTransaction = await account.DepositAsync(500);

        Assert.IsTrue(account.Balance == 500, "Account balance is 500");

    }

​

    public async Task Deposit_Transaction_Test()

    {

        // Create a new account, with a deposit of 500, transaction amount should be 500

        var account = new BankAccount(new Guid(), new Guid(), BankAccountType.Savings); 

        var depositTransaction = await account.DepositAsync(500);

        Assert.IsTrue(depositTransaction.Amount == 500, "Deposit transaction amount is 500");

    }

}