/*
    * GordianKnot: Security Suite
    * 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.gordianknot.impl.bc;
  
  import io.github.tonywasher.joceanus.gordianknot.api.base.GordianException;
  import io.github.tonywasher.joceanus.gordianknot.api.keypair.GordianKeyPair;
  import io.github.tonywasher.joceanus.gordianknot.api.keypair.GordianKeyPairSpec;
  import io.github.tonywasher.joceanus.gordianknot.api.sign.GordianSignParams;
  import io.github.tonywasher.joceanus.gordianknot.api.sign.GordianSignatureSpec;
  import io.github.tonywasher.joceanus.gordianknot.impl.bc.BouncyKeyPair.BouncyPrivateKey;
  import io.github.tonywasher.joceanus.gordianknot.impl.bc.BouncyKeyPair.BouncyPublicKey;
  import io.github.tonywasher.joceanus.gordianknot.impl.core.base.GordianBaseFactory;
  import io.github.tonywasher.joceanus.gordianknot.impl.core.exc.GordianCryptoException;
  import io.github.tonywasher.joceanus.gordianknot.impl.core.keypair.GordianKeyPairValidity;
  import io.github.tonywasher.joceanus.gordianknot.impl.core.sign.GordianCoreSignature;
  import org.bouncycastle.asn1.ASN1Encoding;
  import org.bouncycastle.asn1.pkcs.PrivateKeyInfo;
  import org.bouncycastle.asn1.x509.SubjectPublicKeyInfo;
  import org.bouncycastle.crypto.AsymmetricCipherKeyPair;
  import org.bouncycastle.crypto.CryptoException;
  import org.bouncycastle.crypto.Signer;
  import org.bouncycastle.crypto.generators.Ed25519KeyPairGenerator;
  import org.bouncycastle.crypto.generators.Ed448KeyPairGenerator;
  import org.bouncycastle.crypto.params.AsymmetricKeyParameter;
  import org.bouncycastle.crypto.params.Ed25519KeyGenerationParameters;
  import org.bouncycastle.crypto.params.Ed25519PrivateKeyParameters;
  import org.bouncycastle.crypto.params.Ed25519PublicKeyParameters;
  import org.bouncycastle.crypto.params.Ed448KeyGenerationParameters;
  import org.bouncycastle.crypto.params.Ed448PrivateKeyParameters;
  import org.bouncycastle.crypto.params.Ed448PublicKeyParameters;
  import org.bouncycastle.crypto.signers.Ed25519Signer;
  import org.bouncycastle.crypto.signers.Ed448Signer;
  import org.bouncycastle.crypto.util.PrivateKeyFactory;
  import org.bouncycastle.crypto.util.PrivateKeyInfoFactory;
  import org.bouncycastle.crypto.util.PublicKeyFactory;
  import org.bouncycastle.crypto.util.SubjectPublicKeyInfoFactory;
  
  import java.io.IOException;
  import java.security.spec.PKCS8EncodedKeySpec;
  import java.security.spec.X509EncodedKeySpec;
  import java.util.Arrays;
  
  /**
   * EdwardsCurve DSA KeyPair classes.
   */
  public final class BouncyEdDSAKeyPair {
      /**
       * Private constructor.
       */
      private BouncyEdDSAKeyPair() {
      }
  
      /**
       * Bouncy EdwardsDSA25519 PublicKey.
       */
      public static class BouncyEd25519PublicKey
              extends BouncyPublicKey<Ed25519PublicKeyParameters> {
          /**
           * Constructor.
           *
           * @param pKeySpec   the keySpec
           * @param pPublicKey the public key
           */
          BouncyEd25519PublicKey(final GordianKeyPairSpec pKeySpec,
                                 final Ed25519PublicKeyParameters pPublicKey) {
              super(pKeySpec, pPublicKey);
          }
  
          @Override
          protected boolean matchKey(final AsymmetricKeyParameter pThat) {
              /* Access keys */
              final Ed25519PublicKeyParameters myThis = getPublicKey();
              final Ed25519PublicKeyParameters myThat = (Ed25519PublicKeyParameters) pThat;
  
              /* Compare keys */
              return Arrays.equals(myThis.getEncoded(), myThat.getEncoded());
          }
      }
  
      /**
       * Bouncy EdwardsDSA25519 PrivateKey.
       */
      public static class BouncyEd25519PrivateKey
              extends BouncyPrivateKey<Ed25519PrivateKeyParameters> {
          /**
          * Constructor.
          *
          * @param pKeySpec    the keySpec
          * @param pPrivateKey the private key
          */
         BouncyEd25519PrivateKey(final GordianKeyPairSpec pKeySpec,
                                 final Ed25519PrivateKeyParameters pPrivateKey) {
             super(pKeySpec, pPrivateKey);
         }
 
 
         @Override
         protected boolean matchKey(final AsymmetricKeyParameter pThat) {
             /* Access keys */
             final Ed25519PrivateKeyParameters myThis = getPrivateKey();
             final Ed25519PrivateKeyParameters myThat = (Ed25519PrivateKeyParameters) pThat;
 
             /* Compare keys */
             return Arrays.equals(myThis.getEncoded(), myThat.getEncoded());
         }
     }
 
     /**
      * Bouncy EdwardsDSA448 PublicKey.
      */
     public static class BouncyEd448PublicKey
             extends BouncyPublicKey<Ed448PublicKeyParameters> {
         /**
          * Constructor.
          *
          * @param pKeySpec   the keySpec
          * @param pPublicKey the public key
          */
         BouncyEd448PublicKey(final GordianKeyPairSpec pKeySpec,
                              final Ed448PublicKeyParameters pPublicKey) {
             super(pKeySpec, pPublicKey);
         }
 
         @Override
         protected boolean matchKey(final AsymmetricKeyParameter pThat) {
             /* Access keys */
             final Ed448PublicKeyParameters myThis = getPublicKey();
             final Ed448PublicKeyParameters myThat = (Ed448PublicKeyParameters) pThat;
 
             /* Compare keys */
             return Arrays.equals(myThis.getEncoded(), myThat.getEncoded());
         }
     }
 
     /**
      * Bouncy EdwardsDSA448 PrivateKey.
      */
     public static class BouncyEd448PrivateKey
             extends BouncyPrivateKey<Ed448PrivateKeyParameters> {
         /**
          * Constructor.
          *
          * @param pKeySpec    the keySpec
          * @param pPrivateKey the private key
          */
         BouncyEd448PrivateKey(final GordianKeyPairSpec pKeySpec,
                               final Ed448PrivateKeyParameters pPrivateKey) {
             super(pKeySpec, pPrivateKey);
         }
 
 
         @Override
         protected boolean matchKey(final AsymmetricKeyParameter pThat) {
             /* Access keys */
             final Ed448PrivateKeyParameters myThis = getPrivateKey();
             final Ed448PrivateKeyParameters myThat = (Ed448PrivateKeyParameters) pThat;
 
             /* Compare keys */
             return Arrays.equals(myThis.getEncoded(), myThat.getEncoded());
         }
     }
 
     /**
      * BouncyCastle EdwardsDSA25519 KeyPair generator.
      */
     public static class BouncyEd25519KeyPairGenerator
             extends BouncyKeyPairGenerator {
         /**
          * Generator.
          */
         private final Ed25519KeyPairGenerator theGenerator;
 
         /**
          * Constructor.
          *
          * @param pFactory the Security Factory
          * @param pKeySpec the keySpec
          */
         BouncyEd25519KeyPairGenerator(final GordianBaseFactory pFactory,
                                       final GordianKeyPairSpec pKeySpec) {
             /* Initialise underlying class */
             super(pFactory, pKeySpec);
 
             /* Create the generator */
             theGenerator = new Ed25519KeyPairGenerator();
 
             /* Initialise the generator */
             final Ed25519KeyGenerationParameters myParams = new Ed25519KeyGenerationParameters(getRandom());
             theGenerator.init(myParams);
         }
 
         @Override
         public BouncyKeyPair generateKeyPair() {
             /* Generate and return the keyPair */
             final AsymmetricCipherKeyPair myPair = theGenerator.generateKeyPair();
             final BouncyEd25519PublicKey myPublic = new BouncyEd25519PublicKey(getKeySpec(), (Ed25519PublicKeyParameters) myPair.getPublic());
             final BouncyEd25519PrivateKey myPrivate = new BouncyEd25519PrivateKey(getKeySpec(), (Ed25519PrivateKeyParameters) myPair.getPrivate());
             return new BouncyKeyPair(myPublic, myPrivate);
         }
 
         @Override
         public PKCS8EncodedKeySpec getPKCS8Encoding(final GordianKeyPair pKeyPair) throws GordianException {
             /* Protect against exceptions */
             try {
                 /* Check the keyPair type and keySpecs */
                 BouncyKeyPair.checkKeyPair(pKeyPair, getKeySpec());
 
                 /* build and return the encoding */
                 final BouncyEd25519PrivateKey myPrivateKey = (BouncyEd25519PrivateKey) getPrivateKey(pKeyPair);
                 final Ed25519PrivateKeyParameters myParms = myPrivateKey.getPrivateKey();
                 final PrivateKeyInfo myInfo = PrivateKeyInfoFactory.createPrivateKeyInfo(myParms);
                 return new PKCS8EncodedKeySpec(myInfo.getEncoded());
 
             } catch (IOException e) {
                 throw new GordianCryptoException(ERROR_PARSE, e);
             }
         }
 
         @Override
         public BouncyKeyPair deriveKeyPair(final X509EncodedKeySpec pPublicKey,
                                            final PKCS8EncodedKeySpec pPrivateKey) throws GordianException {
             /* Protect against exceptions */
             try {
                 /* Check the keySpecs */
                 checkKeySpec(pPrivateKey);
 
                 /* derive keyPair */
                 final BouncyEd25519PublicKey myPublic = derivePublicKey(pPublicKey);
                 final PrivateKeyInfo myInfo = PrivateKeyInfo.getInstance(pPrivateKey.getEncoded());
                 final Ed25519PrivateKeyParameters myParms = (Ed25519PrivateKeyParameters) PrivateKeyFactory.createKey(myInfo);
                 final BouncyEd25519PrivateKey myPrivate = new BouncyEd25519PrivateKey(getKeySpec(), myParms);
                 final BouncyKeyPair myPair = new BouncyKeyPair(myPublic, myPrivate);
 
                 /* Check that we have a matching pair */
                 GordianKeyPairValidity.checkValidity(getFactory(), myPair);
 
                 /* Return the keyPair */
                 return myPair;
 
             } catch (IOException e) {
                 throw new GordianCryptoException(ERROR_PARSE, e);
             }
         }
 
         @Override
         public X509EncodedKeySpec getX509Encoding(final GordianKeyPair pKeyPair) throws GordianException {
             /* Protect against exceptions */
             try {
                 /* Check the keyPair type and keySpecs */
                 BouncyKeyPair.checkKeyPair(pKeyPair, getKeySpec());
 
                 /* build and return the encoding */
                 final BouncyEd25519PublicKey myPublicKey = (BouncyEd25519PublicKey) getPublicKey(pKeyPair);
                 final Ed25519PublicKeyParameters myParms = myPublicKey.getPublicKey();
                 final SubjectPublicKeyInfo myInfo = SubjectPublicKeyInfoFactory.createSubjectPublicKeyInfo(myParms);
                 final byte[] myBytes = myInfo.getEncoded(ASN1Encoding.DER);
                 return new X509EncodedKeySpec(myBytes);
 
             } catch (IOException e) {
                 throw new GordianCryptoException(ERROR_PARSE, e);
             }
         }
 
         @Override
         public BouncyKeyPair derivePublicOnlyKeyPair(final X509EncodedKeySpec pEncodedKey) throws GordianException {
             final BouncyEd25519PublicKey myPublic = derivePublicKey(pEncodedKey);
             return new BouncyKeyPair(myPublic);
         }
 
         /**
          * Derive public key from encoded.
          *
          * @param pEncodedKey the encoded key
          * @return the public key
          * @throws GordianException on error
          */
         private BouncyEd25519PublicKey derivePublicKey(final X509EncodedKeySpec pEncodedKey) throws GordianException {
             /* Protect against exceptions */
             try {
                 /* Check the keySpecs */
                 checkKeySpec(pEncodedKey);
 
                 /* derive publicKey */
                 final SubjectPublicKeyInfo myInfo = SubjectPublicKeyInfo.getInstance(pEncodedKey.getEncoded());
                 final Ed25519PublicKeyParameters myParms = (Ed25519PublicKeyParameters) PublicKeyFactory.createKey(myInfo);
                 return new BouncyEd25519PublicKey(getKeySpec(), myParms);
 
             } catch (IOException e) {
                 throw new GordianCryptoException(ERROR_PARSE, e);
             }
         }
     }
 
     /**
      * BouncyCastle EdwardsDSA448 KeyPair generator.
      */
     public static class BouncyEd448KeyPairGenerator
             extends BouncyKeyPairGenerator {
         /**
          * Generator.
          */
         private final Ed448KeyPairGenerator theGenerator;
 
         /**
          * Constructor.
          *
          * @param pFactory the Security Factory
          * @param pKeySpec the keySpec
          */
         BouncyEd448KeyPairGenerator(final GordianBaseFactory pFactory,
                                     final GordianKeyPairSpec pKeySpec) {
             /* Initialise underlying class */
             super(pFactory, pKeySpec);
 
             /* Create the generator */
             theGenerator = new Ed448KeyPairGenerator();
 
             /* Initialise the generator */
             final Ed448KeyGenerationParameters myParams = new Ed448KeyGenerationParameters(getRandom());
             theGenerator.init(myParams);
         }
 
         @Override
         public BouncyKeyPair generateKeyPair() {
             final AsymmetricCipherKeyPair myPair = theGenerator.generateKeyPair();
             final BouncyEd448PublicKey myPublic = new BouncyEd448PublicKey(getKeySpec(), (Ed448PublicKeyParameters) myPair.getPublic());
             final BouncyEd448PrivateKey myPrivate = new BouncyEd448PrivateKey(getKeySpec(), (Ed448PrivateKeyParameters) myPair.getPrivate());
             return new BouncyKeyPair(myPublic, myPrivate);
         }
 
         @Override
         public PKCS8EncodedKeySpec getPKCS8Encoding(final GordianKeyPair pKeyPair) throws GordianException {
             try {
                 BouncyKeyPair.checkKeyPair(pKeyPair, getKeySpec());
                 final BouncyEd448PrivateKey myPrivateKey = (BouncyEd448PrivateKey) getPrivateKey(pKeyPair);
                 final Ed448PrivateKeyParameters myParms = myPrivateKey.getPrivateKey();
                 final PrivateKeyInfo myInfo = PrivateKeyInfoFactory.createPrivateKeyInfo(myParms);
                 return new PKCS8EncodedKeySpec(myInfo.getEncoded());
             } catch (IOException e) {
                 throw new GordianCryptoException(ERROR_PARSE, e);
             }
         }
 
         @Override
         public BouncyKeyPair deriveKeyPair(final X509EncodedKeySpec pPublicKey,
                                            final PKCS8EncodedKeySpec pPrivateKey) throws GordianException {
             try {
                 checkKeySpec(pPrivateKey);
                 final BouncyEd448PublicKey myPublic = derivePublicKey(pPublicKey);
                 final PrivateKeyInfo myInfo = PrivateKeyInfo.getInstance(pPrivateKey.getEncoded());
                 final Ed448PrivateKeyParameters myParms = (Ed448PrivateKeyParameters) PrivateKeyFactory.createKey(myInfo);
                 final BouncyEd448PrivateKey myPrivate = new BouncyEd448PrivateKey(getKeySpec(), myParms);
                 final BouncyKeyPair myPair = new BouncyKeyPair(myPublic, myPrivate);
                 GordianKeyPairValidity.checkValidity(getFactory(), myPair);
                 return myPair;
             } catch (IOException e) {
                 throw new GordianCryptoException(ERROR_PARSE, e);
             }
         }
 
         @Override
         public X509EncodedKeySpec getX509Encoding(final GordianKeyPair pKeyPair) throws GordianException {
             try {
                 BouncyKeyPair.checkKeyPair(pKeyPair, getKeySpec());
                 final BouncyEd448PublicKey myPublicKey = (BouncyEd448PublicKey) getPublicKey(pKeyPair);
                 final Ed448PublicKeyParameters myParms = myPublicKey.getPublicKey();
                 final SubjectPublicKeyInfo myInfo = SubjectPublicKeyInfoFactory.createSubjectPublicKeyInfo(myParms);
                 final byte[] myBytes = myInfo.getEncoded(ASN1Encoding.DER);
                 return new X509EncodedKeySpec(myBytes);
             } catch (IOException e) {
                 throw new GordianCryptoException(ERROR_PARSE, e);
             }
         }
 
         @Override
         public BouncyKeyPair derivePublicOnlyKeyPair(final X509EncodedKeySpec pEncodedKey) throws GordianException {
             final BouncyEd448PublicKey myPublic = derivePublicKey(pEncodedKey);
             return new BouncyKeyPair(myPublic);
         }
 
         /**
          * Derive public key from encoded.
          *
          * @param pEncodedKey the encoded key
          * @return the public key
          * @throws GordianException on error
          */
         private BouncyEd448PublicKey derivePublicKey(final X509EncodedKeySpec pEncodedKey) throws GordianException {
             try {
                 checkKeySpec(pEncodedKey);
                 final SubjectPublicKeyInfo myInfo = SubjectPublicKeyInfo.getInstance(pEncodedKey.getEncoded());
                 final Ed448PublicKeyParameters myParms = (Ed448PublicKeyParameters) PublicKeyFactory.createKey(myInfo);
                 return new BouncyEd448PublicKey(getKeySpec(), myParms);
             } catch (IOException e) {
                 throw new GordianCryptoException(ERROR_PARSE, e);
             }
         }
     }
 
     /**
      * EdDSA signature.
      */
     public static class BouncyEdDSASignature
             extends GordianCoreSignature {
         /**
          * The Signer.
          */
         private Signer theSigner;
 
         /**
          * Constructor.
          *
          * @param pFactory the factory
          * @param pSpec    the signatureSpec.
          */
         BouncyEdDSASignature(final GordianBaseFactory pFactory,
                              final GordianSignatureSpec pSpec) {
             /* Initialise underlying class */
             super(pFactory, pSpec);
         }
 
         /**
          * Create the signer according to the keyPair.
          *
          * @param pKeyPair the keyPair
          * @return the signer
          */
         private static Signer createSigner(final GordianKeyPair pKeyPair) {
             /* Determine the EdwardsCurve */
             final boolean is25519 = pKeyPair.getKeyPairSpec().getEdwardsElliptic().is25519();
             final byte[] myContext = new byte[0];
 
             /* Create the internal digests */
             return is25519
                     ? new Ed25519Signer()
                     : new Ed448Signer(myContext);
         }
 
         @Override
         public void initForSigning(final GordianSignParams pParams) throws GordianException {
             /* Initialise detail */
             super.initForSigning(pParams);
             final GordianKeyPair myPair = getKeyPair();
             BouncyKeyPair.checkKeyPair(myPair);
 
             /* Initialise and set the signer */
             theSigner = createSigner(myPair);
             final BouncyPrivateKey<?> myPrivate = getKeyPair().getPrivateKey();
             theSigner.init(true, myPrivate.getPrivateKey());
         }
 
         @Override
         public void initForVerify(final GordianSignParams pParams) throws GordianException {
             /* Initialise detail */
             super.initForVerify(pParams);
             final GordianKeyPair myPair = getKeyPair();
             BouncyKeyPair.checkKeyPair(myPair);
 
             /* Initialise and set the signer */
             theSigner = createSigner(myPair);
             final BouncyPublicKey<?> myPublic = getKeyPair().getPublicKey();
             theSigner.init(false, myPublic.getPublicKey());
         }
 
         @Override
         public void update(final byte[] pBytes,
                            final int pOffset,
                            final int pLength) {
             theSigner.update(pBytes, pOffset, pLength);
         }
 
         @Override
         public void update(final byte pByte) {
             theSigner.update(pByte);
         }
 
         @Override
         public void update(final byte[] pBytes) {
             theSigner.update(pBytes, 0, pBytes.length);
         }
 
         @Override
         public void reset() {
             theSigner.reset();
         }
 
         @Override
         protected BouncyKeyPair getKeyPair() {
             return (BouncyKeyPair) super.getKeyPair();
         }
 
         @Override
         public GordianBaseFactory getFactory() {
             return (GordianBaseFactory) super.getFactory();
         }
 
         @Override
         public byte[] sign() throws GordianException {
             /* Check that we are in signing mode */
             checkMode(GordianSignatureMode.SIGN);
 
             /* Sign the message */
             try {
                 return theSigner.generateSignature();
             } catch (CryptoException e) {
                 throw new GordianCryptoException(BouncySignature.ERROR_SIGGEN, e);
             }
         }
 
         @Override
         public boolean verify(final byte[] pSignature) throws GordianException {
             /* Check that we are in verify mode */
             checkMode(GordianSignatureMode.VERIFY);
 
             /* Verify the message */
             return theSigner.verifySignature(pSignature);
         }
     }
 }