package org.metricshub.ipmi.core.coding.protocol.encoder;
   
   /*-
    * ╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲
    * IPMI Java Client
    * ჻჻჻჻჻჻
    * Copyright 2023 Verax Systems, MetricsHub
    * ჻჻჻჻჻჻
    * This program is free software: you can redistribute it and/or modify
   * it under the terms of the GNU Lesser General Public License as
   * published by the Free Software Foundation, either version 3 of the
   * License, or (at your option) any later version.
   *
   * This program is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   * GNU General Lesser Public License for more details.
   *
   * You should have received a copy of the GNU General Lesser Public
   * License along with this program.  If not, see
   * <http://www.gnu.org/licenses/lgpl-3.0.html>.
   * ╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱
   */
  
  import org.metricshub.ipmi.core.coding.protocol.AuthenticationType;
  import org.metricshub.ipmi.core.coding.protocol.IpmiMessage;
  import org.metricshub.ipmi.core.coding.protocol.Ipmiv20Message;
  import org.metricshub.ipmi.core.coding.protocol.PayloadType;
  import org.metricshub.ipmi.core.common.TypeConverter;
  
  import java.security.InvalidKeyException;
  
  /**
   * Encodes IPMI v2.0 message.
   */
  public class Protocolv20Encoder extends ProtocolEncoder {
      /**
       * @param ipmiMessage
       *            - IPMI message to be encoded. Must be {@link Ipmiv20Message}.
       * @throws IllegalArgumentException
       *             when IPMI protocol version or authentication type is
       *             incorrect.
       * @throws InvalidKeyException
       *             - when initiation of the confidentiality algorithm fails
       * @see Ipmiv20Message
       */
      @Override
      public byte[] encode(IpmiMessage ipmiMessage) throws InvalidKeyException {
          if (!(ipmiMessage instanceof Ipmiv20Message)) {
              throw new IllegalArgumentException(
                      "IPMIMessage must be in 2.0 version.");
          }
          Ipmiv20Message message = (Ipmiv20Message) ipmiMessage;
  
          byte[] payload = message.getPayload().getEncryptedPayload();
  
          if (payload == null) {
              message.getPayload().encryptPayload(
                      message.getConfidentialityAlgorithm());
              payload = message.getPayload().getEncryptedPayload();
          }
  
          byte[] raw = new byte[getMessageLength(message)];
  
          if (message.getAuthenticationType() != AuthenticationType.RMCPPlus) {
              throw new IllegalArgumentException(
                      "Authentication type must be RMCP+ for IPMI v2.0");
          }
  
          raw[0] = encodeAuthenticationType(message.getAuthenticationType());
  
          int offset = 1;
  
          raw[offset] = encodePayloadType(message.isPayloadEncrypted(),
                  message.isPayloadAuthenticated(), message.getPayloadType());
  
          ++offset;
  
          if (message.getPayloadType() == PayloadType.Oem) {
              encodeOEMIANA(message.getOemIANA(), raw, offset);
              offset += 4;
  
              encodeOEMPayloadId(message.getOemPayloadID(), raw, offset);
              offset += 2;
          }
  
          encodeSessionId(message.getSessionID(), raw, offset);
          offset += 4;
  
          encodeSessionSequenceNumber(message.getSessionSequenceNumber(), raw,
                  offset);
          offset += 4;
  
          encodePayloadLength(payload.length, raw, offset);
          offset += 2;
  
          offset = encodePayload(payload, raw, offset);
  
          if (message.isPayloadAuthenticated() && message.getSessionID() != 0) {
             encodeSessionTrailer(message.getAuthCode(), raw, offset);
         }
 
         return raw;
     }
 
     /**
      * Calculates length of the IPMI message.
      *
      * @param ipmiMessage
      *            - message which length is to be calculated
      */
     private int getMessageLength(Ipmiv20Message ipmiMessage) {
         int length = 12
                 + ipmiMessage.getConfidentialityAlgorithm()
                         .getConfidentialityOverheadSize(
                                 ipmiMessage.getPayloadLength())
                 + ipmiMessage.getPayloadLength();
 
         if (ipmiMessage.getPayloadType() == PayloadType.Oem) {
             length += 6;
         }
 
         if (ipmiMessage.isPayloadAuthenticated()
                 && ipmiMessage.getSessionID() != 0) {
             if (ipmiMessage.getAuthCode() != null) {
                 if ((length + ipmiMessage.getAuthCode().length + 2) % 4 != 0) {
                     length += 4 - (length + ipmiMessage.getAuthCode().length + 2) % 4;
                 }
                 length += ipmiMessage.getAuthCode().length;
             }
             length += 2;
         }
 
         return length;
     }
 
     private byte encodePayloadType(boolean isEncrypted,
             boolean isAuthenticated, PayloadType payloadType) {
         byte result = 0;
 
         if (isEncrypted) {
             result |= TypeConverter.intToByte(0x80);
         }
 
         if (isAuthenticated) {
             result |= TypeConverter.intToByte(0x40);
         }
 
         result |= TypeConverter.intToByte(payloadType.getCode());
 
         return result;
     }
 
     /**
      * Encodes OEM IANA and inserts it into message at given offset.
      *
      * @param value
      * @param message
      *            - IPMI message being created
      * @param offset
      * @throws IndexOutOfBoundsException
      *             when message is too short to hold value at given offset
      */
     private void encodeOEMIANA(int value, byte[] message, int offset) {
         encodeInt(value, message, offset);
     }
 
     /**
      * Encodes OEM payload ID and inserts it into message at given offset. To
      * implement manufacturer-specific OEM Payload ID encoding, override this
      * function.
      *
      * @param value
      * @param message
      *            - IPMI message being created
      * @param offset
      * @throws IndexOutOfBoundsException
      *             when message is too short to hold value at given offset
      * @throws IllegalArgumentException
      *             when value is incorrect.
      */
     protected void encodeOEMPayloadId(Object value, byte[] message, int offset) {
         byte[] oemId = null;
         try {
             oemId = (byte[]) value;
         } catch (Exception e) {
             throw new IllegalArgumentException("Value is corrupted", e);
         }
         if (oemId.length != 2) {
             throw new IllegalArgumentException("Value has invalid length");
         }
         if (oemId.length + offset > message.length) {
             throw new IndexOutOfBoundsException("Message is too short");
         }
 
         System.arraycopy(oemId, 0, message, offset, 2);
     }
 
     @Override
     protected void encodePayloadLength(int value, byte[] message, int offset) {
         byte[] payloadLength = TypeConverter.intToLittleEndianByteArray(value);
         message[offset] = payloadLength[0];
         message[offset + 1] = payloadLength[1];
     }
 
     /**
      * Creates session trailer. <br>
      * Encodes Authorization Code and inserts it into message. <br>
      * Adds integrity pad if needed and inserts pad length and next header
      * fields.
      *
      * @param authCode
      *            - Value of the Authorization Code
      * @param message
      *            - IPMI message being created
      * @param offset
      *            - Should point at the beginning of the session trailer.
      * @throws IndexOutOfBoundsException
      *             when message is too short to hold value at given offset
      * @return Offset pointing after Authorization Code
      */
     private int encodeSessionTrailer(final byte[] authCode, final byte[] message, final int offset) {
         int pad = 0;
 
         if (authCode != null && authCode.length + offset > message.length) {
             throw new IndexOutOfBoundsException("Message is too short");
         }
 
         if (authCode != null) {
             pad = (offset + authCode.length + 2) % 4;
         }
 
         if (pad > 0) {
             pad = 4 - pad;
         } else {
             pad = 0;
         }
 
         int currentOffset = offset;
 
         for (int i = 0; i < pad; ++i) {
             message[currentOffset] = TypeConverter.intToByte(0xff);
             ++currentOffset;
         }
 
         message[currentOffset] = TypeConverter.intToByte(pad);
         ++currentOffset;
 
         // Next header - reserved
         message[currentOffset] = TypeConverter.intToByte(0x07);
         ++currentOffset;
         if (authCode != null) {
             System.arraycopy(authCode, 0, message, currentOffset, authCode.length);
             currentOffset += authCode.length;
         }
 
         return currentOffset;
     }
 }