ophelias-oasis/OpheliasOasis/Models/Transaction.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Ophelias.Models;

namespace Ophelias.Models
{
    internal class Transaction
    {
        private double PenaltyMultipler = 1.1;

        internal int Id;

        internal double Rate;
        internal double Paid;
        internal double Owed;
        internal double? Penalty;
        internal double? Multiplier;
        internal double RefundAmount;

        internal bool? Late;
        internal bool PaidOff;

        internal DateTime PayBy;
        internal DateTime PaidOn;

        internal Transaction(int id, ReservationType type, DateTime payby)
        {
            Id = id;
            Paid = 0;
            Owed = 0;
            RefundAmount = 0;
            PaidOff = false;
            PayBy = payby;
            Multiplier = Fee(type);
        }
        private bool IsOverdue()
        {
            if  (DateTime.Now > PayBy)
            {
                return true;
            }
            return false;
        }

        private void SetChangeFees(ReservationType type, double rate)
        {
            switch (type)
            {
                case ReservationType.Conventional: return;
                case ReservationType.Prepaid: SetFee(PenaltyMultipler); SetRate(rate); return;
                case ReservationType.Incentive: return;
                case ReservationType.SixtyDayAdvance: SetFee(PenaltyMultipler); SetRate(rate); return;
                default: throw new NotImplementedException();
            }
        }
        private void CancellationHandler(ReservationType type)
        {
            void SetRefund()
            {
                if (DateTime.Now.AddDays(+3).Day <= PayBy.Day)
                {
                    RefundAmount = Paid;
                    Paid = 0;
                    Owed = 0;
                    PaidOff = false;
                }
            }

            switch (type)
            {
                case ReservationType.Conventional: SetRefund(); return;
                case ReservationType.Prepaid: return;
                case ReservationType.Incentive: SetRefund(); return;
                case ReservationType.SixtyDayAdvance: return;
                default: throw new NotImplementedException();
            }
        }

        internal void Penalize(ReservationStatus status, ReservationType type, double rate)
        {
            switch(status)
            {
                case ReservationStatus.Active: IsOverdue(); return;
                case ReservationStatus.Cancelled: CancellationHandler(type); return;
                case ReservationStatus.Changed: SetChangeFees(type, rate); return;
            }
        }
        internal double Fee(ReservationType type)
        {
            switch (type)
            {
                case ReservationType.Conventional: return 1.0;
                case ReservationType.Prepaid: return 0.75;
                case ReservationType.Incentive: return 1.0;
                case ReservationType.SixtyDayAdvance: return 0.85;
                default: throw new NotImplementedException();
            }
        }
        internal void SetFee(double mult)
        {
            Multiplier = mult;
        }
        internal void SetRate(double rate)
        {
            Rate = rate;
        }

        internal void Pay(double amount)
        {
            if (RefundAmount > -1)
            {
                return;
            }
            Paid += amount;
            if (Paid == Owed)
            {
                Owed -= Paid;
                PaidOn = DateTime.Now;
                PaidOff = true;
            } else if (Paid > Owed)
            {
                RefundAmount = Paid - Owed;
                Owed = Owed - Paid + RefundAmount;
                PaidOn = DateTime.Now;
                PaidOff = true;
            } else
            {
                Owed -= Paid;
                PaidOn = DateTime.Now;
            }
        }
    }
    internal class TransactionList
    {
        internal List<Transaction> Transactions;

        internal TransactionList()
        {
            Transactions = new List<Transaction>();
        }
    }
}