UVtools/UVtools.Core/Objects/Material.cs

/*
 *                     GNU AFFERO GENERAL PUBLIC LICENSE
 *                       Version 3, 19 November 2007
 *  Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
 *  Everyone is permitted to copy and distribute verbatim copies
 *  of this license document, but changing it is not allowed.
 */

using System;

namespace UVtools.Core.Objects;

/// <summary>
/// Represents a material to feed in the printer
/// </summary>
public class Material : BindableBase, ICloneable
{
    #region Members
    private string _name = null!;
    private uint _bottleVolume = 1000;
    private decimal _density = 1;
    private decimal _bottleCost = 30;
    private int _bottlesInStock = 1;
    private decimal _bottleRemainingVolume = 1000;
    private decimal _consumedVolume;
    private double _printTime;

    #endregion

    #region Properties
    public string Name
    {
        get => _name;
        set => RaiseAndSetIfChanged(ref _name, value);
    }

    /// <summary>
    /// Gets or sets the bottle volume in milliliters
    /// </summary>
    public uint BottleVolume
    {
        get => _bottleVolume;
        set
        {
            if(!RaiseAndSetIfChanged(ref _bottleVolume, value)) return;
            RaisePropertyChanged(nameof(BottleWeight));
            RaisePropertyChanged(nameof(ConsumedBottles));
            RaisePropertyChanged(nameof(TotalCost));
            RaisePropertyChanged(nameof(VolumeInStock));
        }
    }

    /// <summary>
    /// Gets or sets the bottle weight in grams
    /// </summary>
    public decimal BottleWeight => _bottleVolume * _density;

    /// <summary>
    /// Gets or sets the material density in g/ml
    /// </summary>
    public decimal Density
    {
        get => _density;
        set
        {
            if(!RaiseAndSetIfChanged(ref _density, value)) return;
            RaisePropertyChanged(nameof(BottleWeight));
        }
    }

    /// <summary>
    /// Gets or sets the bottle cost
    /// </summary>
    public decimal BottleCost
    {
        get => _bottleCost;
        set
        {
            if(!RaiseAndSetIfChanged(ref _bottleCost, value)) return;
            RaisePropertyChanged(nameof(TotalCost));
        }
    }

    public decimal TotalCost => OwnedBottles * _bottleCost;

    /// <summary>
    /// Gets or sets the number of bottles in stock
    /// </summary>
    public int BottlesInStock
    {
        get => _bottlesInStock;
        set
        {
            if(!RaiseAndSetIfChanged(ref _bottlesInStock, value)) return;
            RaisePropertyChanged(nameof(OwnedBottles));
            RaisePropertyChanged(nameof(TotalCost));
            RaisePropertyChanged(nameof(VolumeInStock));
        }
    }

    /// <summary>
    /// Gets or sets the current bottle remaining material in milliliters
    /// </summary>
    public decimal BottleRemainingVolume
    {
        get => Math.Round(_bottleRemainingVolume, 2);
        set
        {
            if(!RaiseAndSetIfChanged(ref _bottleRemainingVolume, value)) return;
            RaisePropertyChanged(nameof(VolumeInStock));
        }
    }

    /// <summary>
    /// Gets the total available volume in stock in milliliters
    /// </summary>
    public decimal VolumeInStock => _bottlesInStock * _bottleVolume - (_bottleVolume - _bottleRemainingVolume);

    /// <summary>
    /// Gets the number of consumed bottles 
    /// </summary>
    public uint ConsumedBottles => (uint)(_consumedVolume / _bottleVolume);

    /// <summary>
    /// Gets the total number of owned bottles
    /// </summary>
    public int OwnedBottles => (int) (_bottlesInStock + ConsumedBottles);

    /// <summary>
    /// Gets or sets the total number of consumed volume in milliliters
    /// </summary>
    public decimal ConsumedVolume
    {
        get => _consumedVolume;
        set
        {
            if(!RaiseAndSetIfChanged(ref _consumedVolume, value)) return;
            RaisePropertyChanged(nameof(ConsumedVolumeLiters));
        }
    }

    /// <summary>
    /// Gets total number of consumed volume in liters
    /// </summary>
    public decimal ConsumedVolumeLiters => ConsumedVolume / 1000;

    /// <summary>
    /// Gets or sets the total print time using with material in hours
    /// </summary>
    public double PrintTime
    {
        get => _printTime;
        set
        {
            if(!RaiseAndSetIfChanged(ref _printTime, value)) return;
            RaisePropertyChanged(nameof(PrintTimeSpan));
        }
    }

    public TimeSpan PrintTimeSpan => TimeSpan.FromHours(_printTime);

    #endregion

    #region Constructors
    public Material() { }

    public Material(string name, uint bottleVolume = 1000, decimal density = 1, decimal bottleCost = 30, int bottlesInStock = 1)
    {
        _name = name;
        _bottleVolume = bottleVolume;
        _density = density;
        _bottleCost = bottleCost;
        _bottlesInStock = bottlesInStock;
        _bottleRemainingVolume = bottleVolume;
    }
    #endregion

    #region Overrides

    protected bool Equals(Material other)
    {
        return _name == other._name;
    }

    public override bool Equals(object? obj)
    {
        if (ReferenceEquals(null, obj)) return false;
        if (ReferenceEquals(this, obj)) return true;
        if (obj.GetType() != GetType()) return false;
        return Equals((Material) obj);
    }

    public override int GetHashCode()
    {
        return (_name != null ? _name.GetHashCode() : 0);
    }

    public override string ToString()
    {
        return $"{_name} ({_bottleRemainingVolume}/{VolumeInStock}ml)";
    }

    public object Clone()
    {
        return MemberwiseClone();
    }

    public Material CloneMaterial()
    {
        return (Material)Clone();
    }

    #endregion

    #region Methods
    /// <summary>
    /// Gets the cost for a given volume
    /// </summary>
    /// <param name="volume">Volume in ml</param>
    /// <returns></returns>
    public decimal GetVolumeCost(decimal volume) => _bottleVolume > 0 ? volume * _bottleCost / _bottleVolume : 0;

    /// <summary>
    /// Gets the grams for a given volume
    /// </summary>
    /// <param name="volume">Volume in ml</param>
    /// <returns></returns>
    public decimal GetVolumeGrams(decimal volume) => volume * _density;

    /// <summary>
    /// Consume material from current bottle and manage stock
    /// </summary>
    /// <param name="volume">Volume to consume in milliliters</param>
    /// <param name="printSeconds">Time in seconds it took to print</param>
    /// <returns>True if still have bottles in stock, otherwise false</returns>
    public bool Consume(decimal volume, double printSeconds = 0)
    {
        if (volume <= 0 || _bottleVolume == 0) return true; // Safe check
        int consumedBottles = (int)(volume / _bottleVolume);
        decimal remainder = volume % _bottleVolume;

        if (remainder > 0)
        {
            decimal remainingVolume = _bottleRemainingVolume - remainder;
            if (remainingVolume < 0)
            {
                consumedBottles++;
                remainingVolume += _bottleVolume;
            }

            BottleRemainingVolume = remainingVolume;
        }

        BottlesInStock -= consumedBottles;
        ConsumedVolume += volume;

        AddPrintTimeSeconds(printSeconds);

        return _bottlesInStock > 0;
    }

    /// <summary>
    /// Add print time with this material
    /// </summary>
    /// <param name="seconds">Seconds to add</param>
    public void AddPrintTimeSeconds(double seconds)
    {
        if (seconds <= 0) return;
        PrintTime += seconds / 60 / 60;
    }
    #endregion
}