using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

​

namespace AccountLibrary

{

    public interface IBank

    {

        void AddAccount(IAccount account, string key);

        double ProcessTransaction(IAccount account, ITransaction transaction);

        double TransferTransaction(ITransaction transaction, IAccount receiver, IAccount sender);

        IAccount GetAccount(string key, string code, out bool success);

    }

​

    public abstract class AbstractBank : IBank

    {

        public abstract void AddAccount(IAccount account, string key);

        public abstract double ProcessTransaction(IAccount account, ITransaction transaction);

        public abstract double TransferTransaction(ITransaction transaction, IAccount receiver, IAccount sender);

        public abstract IAccount GetAccount(string key, string code, out bool success);

        protected abstract IAccount GetAccount(string key, out bool success);

    }

​

    public class Bank : AbstractBank

    {

        //List<IAccount> accounts = new List<IAccount>();

        Dictionary<string, IAccount> accounts = new Dictionary<string, IAccount>();

​

        //public void AddAccount(IAccount account)

        //{

        //    accounts.Add(account);

        //}

        public override void AddAccount(IAccount account, string key)

        {

            if (!accounts.ContainsKey(key))

                accounts.Add(key, account);

            else Console.WriteLine("Error! An account using key:{0} already exists!", key);

        }

​

        protected override IAccount GetAccount(string key, out bool success)

        {

            IAccount account;

            bool has = accounts.TryGetValue(key, out account); 

            success = has;

            if (success)

            { 

                return account;

            }

            else

            {

                Console.WriteLine("Error! No account found for key: {0}", key);

                return null;

            }

        }

​

        public override IAccount GetAccount(string key, string code, out bool success)

        {

            if (code != key)

            {

                Console.WriteLine("Error! Account key does not match code for {1}", code);

                success = false;

                return null;

            }

​

            return GetAccount(key, out success);

        }

​

        public override double ProcessTransaction(IAccount account, ITransaction transaction)

        {

            return transaction.Operate(account);

        }

​

        public override double TransferTransaction(ITransaction transaction, IAccount receiver, IAccount sender)

        {

            transaction.Operate(receiver);

            return transaction.ReverseOperate(sender);

        }

​

        public List<ITransaction> FindTransaction(IEnumerable<Func<IAccount, ITransaction>> funcList)

        {

            List<ITransaction> result = new List<ITransaction>();

​

            //foreach (var account in accounts)

            foreach (var account in accounts.Values)

            {

                foreach (var func in funcList)

                {

                    ITransaction res = func(account);

                    if (res != default(ITransaction))

                        result.Add(res);

                }

            }

            return result;

        }

​

        public List<ITransaction> FindTransaction(IEnumerable<Func<IAccount, ITransaction>> funcList, IAccount account)

        {

            List<ITransaction> result = new List<ITransaction>();

​

            foreach (var func in funcList)

            {

                ITransaction res = func(account);

                if (res != default(ITransaction))

                    result.Add(res);

            }

            return result;

        }

    }

​

    public class ATM

    {

        private AbstractBank bank;

        //private ITransaction CreateTransactionDeposit(double amount, DateTime date) => new TransactionDeposit(amount, date);

        //private ITransaction CreateTransactionWithdraw(double amount, DateTime date) => new TransactionWithdraw(amount, date);

         private ITransaction CreateTransactionDeposit(double amount, DateTime date) { return new TransactionDeposit(amount, date);}

        private ITransaction CreateTransactionWithdraw(double amount, DateTime date) { return new TransactionWithdraw(amount, date);}

​

        private ATM()

        {

            bank = new Bank();

        }

​

        public static ATM CreateATM(string auth)

        {

            return new ATM();

        }

        public void AddAccount(IAccount account, string key)

        {

            bank.AddAccount(account, key);

        }

​

        private double TransferTransaction(ITransaction transaction, IAccount receiver, IAccount sender)

        {

            return bank.TransferTransaction(transaction, receiver, sender);

        }

​

        private IAccount GetAccount(string key, string code, out bool success)

        {

            return bank.GetAccount(key, code, out success);

        }

​

        public double AuthorizeDeposit(double amount, string key, string code, out bool success)

        {

            IAccount account = bank.GetAccount(key, code, out success);

            if (success) {

                return bank.ProcessTransaction(account, CreateTransactionDeposit(amount, DateTime.Now));                

            }

​

            return -1;

        }

​

        public double AuthorizeWithdraw(double amount, string key, string code, out bool success)

        {

            IAccount account = bank.GetAccount(key, code, out success);

            if (success)

            {

                return bank.ProcessTransaction(account, CreateTransactionWithdraw(amount, DateTime.Now));                

            }

​

            return -1;

        }

​

        public double AuthorizeTransfer(double amount,  string key, string code, out bool success, IAccount targetAccount) // todo hide target Account with routing system

        {

            IAccount account = GetAccount(key, code, out success);

            if (success)

            {

                return TransferTransaction(CreateTransactionWithdraw(amount, DateTime.Now), targetAccount, account);

            }

​

            return -1;

        }

​

        private abstract class Transaction : ITransaction

        {

​

            public DateTime Date { get; set; }

            public string Description { get; set; }

            public double Amount { get; set; }

            public abstract double Operate(IAccount account);

            public abstract double ReverseOperate(IAccount account);

​

            /*public void AddToTransactions(IAccount account)

            {

                account.Transactions.Add(this);

            }*/

​

            public  Transaction(double amount, string type, DateTime date)

            {

                Amount = amount;

                Description = type;

                Date = date;

            }

        }

​

        private class TransactionWithdraw : Transaction

        {

            public override double Operate(IAccount account)

            {

                //AddToTransactions(account);

                return account.Withdraw(this);

            }

​

            public override double ReverseOperate(IAccount account)

            {

                //AddToTransactions(account);

                return account.Deposit(this);

            }

​

            public TransactionWithdraw(double amount, DateTime date) : base(amount, "withdraw", date)

            {

​

            }

​

        }

​

        private class TransactionDeposit : Transaction

        {

            public override double Operate(IAccount account)

            {

                //AddToTransactions(account);

                return account.Deposit(this);

            }

​

            public override double ReverseOperate(IAccount account)

            {

                //AddToTransactions(account);

                return account.Withdraw(this);

            }

​

            public TransactionDeposit(double amount, DateTime date) : base(amount, "deposit", date)

            {

​

            }

        }

    }

​

​

    public interface IAccountInfo

    {

        string Name { get; set; }

        double Balance { get; set; }

        List<ITransaction> Transactions { get; set; }

    }

​

    public interface IAccount : IAccountInfo

    {

        double CheckBalance();

        double MonthlyReport();

        double TransactionReport();

        void SaveTransactions();

        List<ITransaction> LoadTransactions();

        //double Withdraw(double amount); // returns withdrawn amount

        //double Deposit(double amount); // return total account value

        void SetBalance(double value);

        //void GetTransaction(ITransaction transaction);

        //void AddTransaction(ITransaction transaction);

        double Deposit(ITransaction transaction);

        double Withdraw(ITransaction transaction);

    }

​

    public abstract class Account : IAccount

    {

        public string Name { get; set; }

        public double Balance { get; set; }

        public List<ITransaction> Transactions { get; set; }

​

        public abstract double CheckBalance();

        public abstract double MonthlyReport();

        public abstract double TransactionReport();

        public abstract void SaveTransactions();

        public abstract List<ITransaction> LoadTransactions();

        protected abstract double Withdraw(double amount); // returns withdrawn amount

        protected abstract double Deposit(double amount);  // returns total account value

        public abstract void SetBalance(double value);

​

        public Account()

        {

            Transactions = new List<ITransaction>();

        }

        public double Deposit(ITransaction transaction)

        {

            Transactions.Add(transaction);

            return Deposit(transaction.Amount);

        }

​

        public double Withdraw(ITransaction transaction)

        {

            Transactions.Add(transaction);

            return Withdraw(transaction.Amount);

        }     

    }

​

    public class CheckingAccount : Account

    {

        public override double CheckBalance()

        {

            return Balance;

        }

        public override double MonthlyReport()

        {

            throw new NotImplementedException();

​

        }

        public override double TransactionReport()

        {

            throw new NotImplementedException();

        }

        public override void SaveTransactions()

        {

            throw new NotImplementedException();

        }

        public override List<ITransaction> LoadTransactions()

        {

            throw new NotImplementedException();

        }

​

        protected override double Withdraw(double amount)

        {

            double currBal = CheckBalance();

            SetBalance(currBal - amount);

            return amount;

        }

​

        protected override double Deposit(double amount)

        {

            double currBal = CheckBalance();

            SetBalance(currBal + amount);

            return CheckBalance();

        }

​

        public override void SetBalance(double value)

        {

            Balance = value;

        }

    }

​

    public class CreditAccount : Account

    {

​

        public override double CheckBalance()

        {

            return Balance;

        }

        public override double MonthlyReport()

        {

            return 0;

        }

        public override double TransactionReport()

        {

            return 0;

        }

        public override void SaveTransactions()

        {

            throw new NotImplementedException();

        }

        public override List<ITransaction> LoadTransactions()

        {

            return Transactions;

        }

​

        protected override double Withdraw(double amount)

        {

            double currBal = CheckBalance();

            currBal += amount;

            SetBalance(currBal);

            return amount;

        }

​

        protected override double Deposit(double amount)

        {

            double currBal = CheckBalance();

            double finalAMount = currBal - amount;

            SetBalance(finalAMount);

            return currBal;

        }

​

        public override void SetBalance(double value)

        {

            Balance = value;

        }

    }

​

    public class CashAccount : Account

    {

        public override double CheckBalance()

        {

            return Balance;

        }

        public override double MonthlyReport()

        {

            throw new NotImplementedException();

​

        }

        public override double TransactionReport()

        {

            throw new NotImplementedException();

        }

        public override void SaveTransactions()

        {

            throw new NotImplementedException();

        }

        public override List<ITransaction> LoadTransactions()

        {

            return Transactions;

        }

​

        protected override double Withdraw(double amount)

        {

            double currBal = CheckBalance();

            if (currBal > 0)

            {

                //double newBal = currBal;

                if (currBal > amount)

                {

                    //newBal = amount;

                    SetBalance(currBal - amount);

                    return amount;

                }

                else

                {

                    //newBal = currBal;

                    SetBalance(0);

                    //return newBal; 

                    return currBal;

                }

            }

            return 0;

        }

​

        protected override double Deposit(double amount)

        {

            double currVal = CheckBalance();

            currVal += amount;

            SetBalance(currVal);

            return CheckBalance();

        }

​

        public override void SetBalance(double value)

        {

            Balance = value;

        }

​

    }

​

    public interface ITransaction

    {

        DateTime Date { get; set; }

        string Description { get; set; }

        double Amount { get; set; }

        double Operate(IAccount account);

        double ReverseOperate(IAccount account);

    }

​

​

​

    public class Program

    {

​

        static public void Main(string[] args)

        {

​

            Bank bank = new Bank();

            ATM atm = ATM.CreateATM("guestAuth");

            string key = "abc";

            string code = key;

            IAccount account = new CheckingAccount();

            //bank.AddAccount(account);

            atm.AddAccount(account, key); 

            Console.WriteLine("balance: " + account.Balance);

            //bank.ProcessTransaction(account, new TransactionDeposit(50.50, DateTime.Now));

            bool successfulDeposit;

            atm.AuthorizeDeposit(50.50, key, code, out successfulDeposit);

​

            Console.WriteLine("new balance: " + account.Balance);

            Console.WriteLine("count: " + account.Transactions.Count);

​

            string key1 = "zyx";

            string code1 = key1;

​

            IAccount account1 = new CreditAccount();

            //bank.AddAccount(account1);

            atm.AddAccount(account1, key1);

            Console.WriteLine("balance1: " + account1.Balance);

            //bank.ProcessTransaction(account1, new TransactionWithdraw(500.00, DateTime.Now));

            bool successfulWithdraw;

            atm.AuthorizeWithdraw(500.00, key1, code1, out successfulWithdraw);

            Console.WriteLine("new balance1: " + account1.Balance);

            Console.WriteLine("count1: " + account1.Transactions.Count);

            atm.AuthorizeDeposit(800.00, key1, code1, out successfulDeposit);

              Console.WriteLine("new balance1: " + account1.Balance);

            Console.WriteLine("count1: " + account1.Transactions.Count);

            string key2 = "zwer";

            string code2 = key2;

​

            IAccount account2 = new CashAccount();

            //bank.AddAccount(account1);

            atm.AddAccount(account2, key2);

            atm.AuthorizeDeposit(100.00, key2, code2, out successfulDeposit);

            Console.WriteLine("balance2: " + account2.Balance);

            //bank.ProcessTransaction(account1, new TransactionWithdraw(500.00, DateTime.Now));

            double withdraw = atm.AuthorizeWithdraw(50.00, key2, code2, out successfulWithdraw);

            Console.WriteLine("withdrawn: {0}", withdraw); 

            Console.WriteLine("new balance2: " + account2.Balance);

            Console.WriteLine("count2: " + account2.Transactions.Count);

​

        }

    }

​

}