/*
 *  Licensed to the Apache Software Foundation (ASF) under one
 *  or more contributor license agreements.  See the NOTICE file
 *  distributed with this work for additional information
 *  regarding copyright ownership.  The ASF licenses this file
 *  to you 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 org.apache.directory.kerberos.credentials.cache;


import java.io.DataOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.util.List;

import org.apache.directory.api.util.Strings;
import org.apache.directory.shared.kerberos.KerberosTime;
import org.apache.directory.shared.kerberos.codec.KerberosEncoder;
import org.apache.directory.shared.kerberos.components.AuthorizationData;
import org.apache.directory.shared.kerberos.components.AuthorizationDataEntry;
import org.apache.directory.shared.kerberos.components.EncryptionKey;
import org.apache.directory.shared.kerberos.components.HostAddress;
import org.apache.directory.shared.kerberos.components.HostAddresses;
import org.apache.directory.shared.kerberos.components.PrincipalName;
import org.apache.directory.shared.kerberos.messages.Ticket;


/**
 * Writing credentials cache according to FCC format by reference the following
 * https://www.gnu.org/software/shishi/manual/html_node/The-Credential-Cache-Binary-File-Format.html
 * 
 * @author <a href="mailto:dev@directory.apache.org">Apache Directory Project</a>
 */
public class CacheOutputStream extends DataOutputStream
{

    public CacheOutputStream( OutputStream out )
    {
        super( out );
    }


    public void write( CredentialsCache credCache ) throws IOException
    {
        /**
         * Currently we always write using this version to limit the test effort.
         * This version seems to be the easiest to be compatible with MIT tools.
         * In future we might allow to specify the format version to write if necessary. 
         */
        int writeVersion = CredentialsCacheConstants.FCC_FVNO_3;

        writeVersion( writeVersion );

        if ( writeVersion == CredentialsCacheConstants.FCC_FVNO_4 )
        {
            writeTags( credCache.getTags() );
        }

        writePrincipal( credCache.getPrimaryPrincipalName(), writeVersion );

        List<Credentials> credentialsList = credCache.getCredsList();
        if ( credentialsList != null )
        {
            for ( Credentials cred : credentialsList )
            {
                writeCredentials( cred, writeVersion );
            }
        }
    }


    private void writeVersion( int version ) throws IOException
    {
        writeShort( version );
    }


    private void writeTags( List<Tag> tags ) throws IOException
    {
        int length = 0;
        if ( tags != null )
        {
            for ( Tag tag : tags )
            {
                if ( tag.tag != CredentialsCacheConstants.FCC_TAG_DELTATIME )
                {
                    continue;
                }
                length += tag.length;
            }
        }

        writeShort( length );

        if ( tags != null )
        {
            for ( Tag tag : tags )
            {
                if ( tag.tag != CredentialsCacheConstants.FCC_TAG_DELTATIME )
                {
                    continue;
                }
                writeTag( tag );
            }
        }
    }


    private void writeTag( Tag tag ) throws IOException
    {
        writeShort( tag.tag );
        writeShort( tag.length );
        writeInt( tag.time );
        writeInt( tag.usec );
    }


    private void writePrincipal( PrincipalName pname, int version ) throws IOException
    {
        int num = pname.getNames().size();

        if ( version != CredentialsCacheConstants.FCC_FVNO_1 )
        {
            writeInt( pname.getNameType().getValue() );
        }
        else
        {
            num++;
        }

        writeInt( num );

        if ( pname.getRealm() != null )
        {
            byte[] realmBytes = null;
            realmBytes = Strings.getBytesUtf8( pname.getRealm() );
            writeInt( realmBytes.length );
            write( realmBytes );
        }
        else
        {
            writeInt( 0 );
        }

        byte[] bytes = null;
        for ( int i = 0; i < pname.getNames().size(); i++ )
        {
            bytes = Strings.getBytesUtf8( pname.getNames().get( i ) );
            writeInt( bytes.length );
            write( bytes );
        }
    }


    private void writeCredentials( Credentials creds, int version ) throws IOException
    {
        writePrincipal( creds.getClientName(), version );
        writePrincipal( creds.getServerName(), version );
        writeKey( creds.getKey(), version );

        writeKerberosTime( creds.getAuthTime() );
        writeKerberosTime( creds.getStartTime() );
        writeKerberosTime( creds.getEndTime() );
        writeKerberosTime( creds.getRenewTill() );

        writeByte( creds.isEncInSKey() ? 1 : 0 );

        writeInt( creds.getFlags().getIntValue() );

        writeAddrs( creds.getClientAddresses() );
        writeAuth( creds.getAuthzData() );

        writeTicket( creds.getTicket() );
        writeTicket( creds.getSecondTicket() );
    }


    private void writeKerberosTime( KerberosTime ktime ) throws IOException
    {
        int time = 0;
        if ( ktime != null )
        {
            time = ( int ) ( ktime.getTime() / 1000 );
        }
        writeInt( time );
    }


    private void writeKey( EncryptionKey key, int version ) throws IOException
    {
        writeShort( key.getKeyType().getValue() );
        if ( version == CredentialsCacheConstants.FCC_FVNO_3 )
        {
            writeShort( key.getKeyType().getValue() );
        }
        // It's not correct with "uint16_t keylen", instead "uint32_t keylen" in keyblock       
        writeInt( key.getKeyValue().length );
        write( key.getKeyValue() );
    }


    private void writeAddrs( HostAddresses addresses ) throws IOException
    {
        if ( addresses == null )
        {
            writeInt( 0 );
        }
        else
        {
            HostAddress[] addrs = addresses.getAddresses();
            write( addrs.length );
            for ( int i = 0; i < addrs.length; i++ )
            {
                write( addrs[i].getAddrType().getValue() );
                write( addrs[i].getAddress().length );
                write( addrs[i].getAddress(), 0,
                    addrs[i].getAddress().length );
            }
        }
    }


    private void writeAuth( AuthorizationData authData ) throws IOException
    {
        if ( authData == null )
        {
            writeInt( 0 );
        }
        else
        {
            for ( AuthorizationDataEntry ade : authData.getAuthorizationData() )
            {
                write( ade.getAdType().getValue() );
                write( ade.getAdData().length );
                write( ade.getAdData() );
            }
        }
    }


    private void writeTicket( Ticket t ) throws IOException
    {
        if ( t == null )
        {
            writeInt( 0 );
        }
        else
        {
            byte[] bytes = KerberosEncoder.encode( t, false ).array();
            writeInt( bytes.length );
            write( bytes );
        }
    }
}