/*
    * 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();
          adjustToScale(theCurrency.getDefaultFractionDigits());
      }
  
      /**
       * 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;
     }
 }