OceanusMoney

/*
 * Oceanus: Java Utilities
 * Copyright 2012-2026. Tony Washer
 *
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not
 * use this file except in compliance with the License.  You may obtain a copy
 * of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
 * License for the specific language governing permissions and limitations under
 * the License.
 */
package io.github.tonywasher.joceanus.oceanus.decimal;

import java.nio.charset.StandardCharsets;
import java.text.DecimalFormatSymbols;
import java.util.Arrays;
import java.util.Currency;
import java.util.Locale;
import java.util.Objects;

/**
 * Represents a Money object.
 */
public class OceanusMoney
        extends OceanusDecimal {
    /**
     * Money Byte length.
     */
    public static final int BYTE_LEN = Long.BYTES + 4;

    /**
     * Currency code length.
     */
    private static final int CURRCODE_LEN = 2;

    /**
     * Invalid Currency error text.
     */
    static final String ERROR_DIFFER = "Cannot add together two different currencies";

    /**
     * Default currency.
     */
    static final Currency DEFAULT_CURRENCY = determineDefaultCurrency();

    /**
     * Currency for money.
     */
    private final Currency theCurrency;

    /**
     * Constructor for money of value zero in the default currency.
     */
    public OceanusMoney() {
        this(DEFAULT_CURRENCY);
    }

    /**
     * Constructor for money of value zero.
     *
     * @param pCurrency the currency
     */
    public OceanusMoney(final Currency pCurrency) {
        theCurrency = pCurrency;
        recordScale(theCurrency.getDefaultFractionDigits());
    }

    /**
     * Construct a new OceanusMoney by copying another money.
     *
     * @param pMoney the Money to copy
     */
    public OceanusMoney(final OceanusMoney pMoney) {
        super(pMoney.unscaledValue(), pMoney.scale());
        theCurrency = pMoney.getCurrency();
    }

    /**
     * Constructor for money from a decimal string.
     *
     * @param pSource The source decimal string
     * @throws IllegalArgumentException on invalidly formatted argument
     */
    public OceanusMoney(final String pSource) {
        /* Use default constructor */
        this();

        /* Parse the string and correct the scale */
        OceanusDecimalParser.parseDecimalValue(pSource, this);
        adjustToScale(theCurrency.getDefaultFractionDigits());
    }

    /**
     * Constructor for money from a decimal string.
     *
     * @param pSource   The source decimal string
     * @param pCurrency the currency
     * @throws IllegalArgumentException on invalidly formatted argument
     */
    public OceanusMoney(final String pSource,
                        final Currency pCurrency) {
        /* Use currency constructor */
        this(pCurrency);

        /* Parse the string and correct the scale */
        OceanusDecimalParser.parseDecimalValue(pSource, this);
        adjustToScale(theCurrency.getDefaultFractionDigits());
    }

    /**
     * Construct a new OceanusMoney by combining units and price.
     *
     * @param pUnits the number of units
     * @param pPrice the price of each unit
     */
    protected OceanusMoney(final OceanusUnits pUnits,
                           final OceanusPrice pPrice) {
        this(pPrice.getCurrency());
        calculateProduct(pUnits, pPrice);
    }

    /**
     * Construct a new OceanusMoney by combining money and rate.
     *
     * @param pMoney the Money to apply rate to
     * @param pRate  the Rate to apply
     */
    private OceanusMoney(final OceanusMoney pMoney,
                         final OceanusRate pRate) {
        this(pMoney.getCurrency());
        calculateProduct(pMoney, pRate);
    }

    /**
     * Construct a new Money by combining money and ratio.
     *
     * @param pMoney the Money to apply ratio to
     * @param pRatio the Ratio to apply
     */
    private OceanusMoney(final OceanusMoney pMoney,
                         final OceanusRatio pRatio) {
        this(pMoney.getCurrency());
        calculateProduct(pMoney, pRatio);
    }

    /**
     * Create the decimal from a byte array.
     *
     * @param pBuffer the buffer
     */
    public OceanusMoney(final byte[] pBuffer) {
        super(pBuffer);
        if (pBuffer.length < Long.BYTES + 1 + CURRCODE_LEN) {
            throw new IllegalArgumentException();
        }
        final byte[] myCurr = Arrays.copyOfRange(pBuffer, Long.BYTES + 1, pBuffer.length);
        final String myCurrCode = new String(myCurr);
        theCurrency = Currency.getInstance(myCurrCode);
    }

    /**
     * Access the currency.
     *
     * @return the currency
     */
    public Currency getCurrency() {
        return theCurrency;
    }

    /**
     * Factory method for generating whole monetary units for a currency (e.g. £)
     *
     * @param pUnits    the number of whole monetary units
     * @param pCurrency the currency
     * @return the allocated money
     */
    public static OceanusMoney getWholeUnits(final long pUnits,
                                             final Currency pCurrency) {
        /* Allocate the money */
        final OceanusMoney myResult = new OceanusMoney(pCurrency);
        final int myScale = myResult.scale();
        myResult.setValue(adjustDecimals(pUnits, myScale), myScale);
        return myResult;
    }

    /**
     * Factory method for generating whole monetary units (e.g. £)
     *
     * @param pUnits the number of whole monetary units
     * @return the allocated money
     */
    public static OceanusMoney getWholeUnits(final long pUnits) {
        /* Allocate the money */
        final OceanusMoney myResult = new OceanusMoney();
        final int myScale = myResult.scale();
        myResult.setValue(adjustDecimals(pUnits, myScale), myScale);
        return myResult;
    }

    /**
     * Add a monetary amount to the value.
     *
     * @param pValue The money to add to this one.
     */
    public void addAmount(final OceanusMoney pValue) {
        /* Currency must be identical */
        if (!theCurrency.equals(pValue.getCurrency())) {
            throw new IllegalArgumentException(ERROR_DIFFER);
        }

        /* Add the value */
        super.addValue(pValue);
    }

    /**
     * Subtract a monetary amount from the value.
     *
     * @param pValue The money to subtract from this one.
     */
    public void subtractAmount(final OceanusMoney pValue) {
        /* Currency must be identical */
        if (!theCurrency.equals(pValue.getCurrency())) {
            throw new IllegalArgumentException(ERROR_DIFFER);
        }

        /* Subtract the value */
        super.subtractValue(pValue);
    }

    @Override
    public void addValue(final OceanusDecimal pValue) {
        throw new UnsupportedOperationException();
    }

    @Override
    public void subtractValue(final OceanusDecimal pValue) {
        throw new UnsupportedOperationException();
    }

    /**
     * Obtain value in different currency.
     *
     * @param pCurrency the currency to convert to
     * @return the converted money in the new currency
     */
    public OceanusMoney changeCurrency(final Currency pCurrency) {
        /* Convert currency with an exchange rate of one */
        return convertCurrency(pCurrency, OceanusRatio.ONE);
    }

    /**
     * Obtain converted money.
     *
     * @param pCurrency the currency to convert to
     * @param pRate     the conversion rate
     * @return the converted money in the new currency
     */
    public OceanusMoney convertCurrency(final Currency pCurrency,
                                        final OceanusRatio pRate) {
        /* If this is the same currency then no conversion */
        if (theCurrency.equals(pCurrency)) {
            return new OceanusMoney(this);
        }

        /* Create the new Money */
        final OceanusMoney myResult = new OceanusMoney(pCurrency);
        myResult.calculateProduct(this, pRate);
        return myResult;
    }

    /**
     * obtain a Diluted money.
     *
     * @param pDilution the dilution factor
     * @return the calculated value
     */
    public OceanusMoney getDilutedMoney(final OceanusRatio pDilution) {
        /* Calculate diluted value */
        return new OceanusMoney(this, pDilution);
    }

    /**
     * calculate the value of this money at a given rate.
     *
     * @param pRate the rate to calculate at
     * @return the calculated value
     */
    public OceanusMoney valueAtRate(final OceanusRate pRate) {
        /* Calculate the money at this rate */
        return new OceanusMoney(this, pRate);
    }

    /**
     * calculate the value of this money at a given ratio.
     *
     * @param pRatio the ratio to multiply by
     * @return the calculated value
     */
    public OceanusMoney valueAtRatio(final OceanusRatio pRatio) {
        /* Calculate the money at this rate */
        return new OceanusMoney(this, pRatio);
    }

    /**
     * calculate the gross value of this money at a given rate used to convert from net to gross
     * values form interest and dividends.
     *
     * @param pRate the rate to calculate at
     * @return the calculated value
     */
    public OceanusMoney grossValueAtRate(final OceanusRate pRate) {
        /* Calculate the Gross corresponding to this net value at the rate */
        final OceanusRatio myRatio = pRate.getRemainingRate().getInverseRatio();
        return new OceanusMoney(this, myRatio);
    }

    /**
     * calculate the TaxCredit value of this money at a given rate used to convert from net to
     * gross. values form interest and dividends
     *
     * @param pRate the rate to calculate at
     * @return the calculated value
     */
    public OceanusMoney taxCreditAtRate(final OceanusRate pRate) {
        /* Calculate the Tax Credit corresponding to this net value at the rate */
        final OceanusRatio myRatio = new OceanusRatio(pRate, pRate.getRemainingRate());
        return new OceanusMoney(this, myRatio);
    }

    /**
     * calculate the value of this money at a given proportion (i.e. weight/total).
     *
     * @param pWeight the weight of this item
     * @param pTotal  the total weight of all the items
     * @return the calculated value
     */
    public OceanusMoney valueAtWeight(final OceanusMoney pWeight,
                                      final OceanusMoney pTotal) {
        /* Handle zero total */
        if (!pTotal.isNonZero()) {
            return new OceanusMoney(theCurrency);
        }

        /* Calculate the defined ratio of this value */
        final OceanusRatio myRatio = new OceanusRatio(pWeight, pTotal);
        return new OceanusMoney(this, myRatio);
    }

    /**
     * calculate the value of this money at a given proportion (i.e. weight/total).
     *
     * @param pWeight the weight of this item
     * @param pTotal  the total weight of all the items
     * @return the calculated value
     */
    public OceanusMoney valueAtWeight(final OceanusUnits pWeight,
                                      final OceanusUnits pTotal) {
        /* Handle zero total */
        if (!pTotal.isNonZero()) {
            return new OceanusMoney(theCurrency);
        }

        /* Calculate the defined ratio of this value */
        final OceanusRatio myRatio = new OceanusRatio(pWeight, pTotal);
        return new OceanusMoney(this, myRatio);
    }

    /**
     * Determine default currency.
     *
     * @return the default currency
     */
    private static Currency determineDefaultCurrency() {
        /* Obtain the default currency */
        final Currency myCurrency = DecimalFormatSymbols.getInstance().getCurrency();

        /* If the default is a pseudo-currency then default to GBP */
        return myCurrency.getDefaultFractionDigits() < 0
                ? Currency.getInstance(Locale.UK)
                : myCurrency;
    }

    /**
     * Obtain default currency.
     *
     * @return the default currency
     */
    public static Currency getDefaultCurrency() {
        return DEFAULT_CURRENCY;
    }

    @Override
    public boolean equals(final Object pThat) {
        /* Handle trivial cases */
        if (this == pThat) {
            return true;
        }
        if (pThat == null) {
            return false;
        }

        /* Make sure that the object is the same class */
        if (getClass() != pThat.getClass()) {
            return false;
        }

        /* Cast as money */
        final OceanusMoney myThat = (OceanusMoney) pThat;

        /* Check currency */
        if (!theCurrency.equals(myThat.getCurrency())) {
            return false;
        }

        /* Check value and scale */
        return super.equals(pThat);
    }

    @Override
    public int hashCode() {
        return Objects.hash(theCurrency, super.hashCode());
    }

    @Override
    public byte[] toBytes() {
        final byte[] myBase = super.toBytes();
        final byte[] myCurr = theCurrency.getCurrencyCode().getBytes(StandardCharsets.UTF_8);
        final byte[] myResult = Arrays.copyOf(myBase, myBase.length + myCurr.length);
        System.arraycopy(myCurr, 0, myResult, myBase.length, myCurr.length);
        return myResult;
    }
}