/*
 *  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.server.dhcp.io;


import java.io.UnsupportedEncodingException;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.nio.ByteBuffer;
import java.util.Arrays;

import org.apache.directory.server.dhcp.DhcpException;
import org.apache.directory.server.dhcp.messages.DhcpMessage;
import org.apache.directory.server.dhcp.messages.HardwareAddress;
import org.apache.directory.server.dhcp.options.DhcpOption;
import org.apache.directory.server.dhcp.options.OptionsField;
import org.apache.directory.server.dhcp.options.dhcp.DhcpMessageType;
import org.apache.directory.server.dhcp.options.dhcp.UnrecognizedOption;
import org.apache.directory.server.i18n.I18n;


/**
 * @author <a href="mailto:dev@directory.apache.org">Apache Directory Project</a>
 */
public class DhcpMessageDecoder
{

    /**
     * Convert a byte buffer into a DhcpMessage.
     * 
     * @return a DhcpMessage.
     * @param buffer ByteBuffer to convert to a DhcpMessage object
     * @throws DhcpException 
     */
    public DhcpMessage decode( ByteBuffer buffer ) throws DhcpException
    {
        byte op = buffer.get();

        short htype = ( short ) ( buffer.get() & 0xff );
        short hlen = ( short ) ( buffer.get() & 0xff );
        short hops = ( short ) ( buffer.get() & 0xff );
        int xid = buffer.getInt();
        int secs = buffer.getShort() & 0xffff;
        short flags = buffer.getShort();

        InetAddress ciaddr = decodeAddress( buffer );
        InetAddress yiaddr = decodeAddress( buffer );
        InetAddress siaddr = decodeAddress( buffer );
        InetAddress giaddr = decodeAddress( buffer );

        byte[] chaddr = decodeBytes( buffer, 16 );

        String sname = decodeString( buffer, 64 );
        String file = decodeString( buffer, 128 );

        OptionsField options = decodeOptions( buffer );

        // message type option: may be null if option isn't set (BOOTP)
        DhcpMessageType mto = ( DhcpMessageType ) options.get( DhcpMessageType.class );

        return new DhcpMessage( null != mto ? mto.getType() : null, op, new HardwareAddress( htype, hlen, chaddr ),
            hops, xid, secs, flags, ciaddr, yiaddr, siaddr, giaddr, sname, file, options );
    }


    /**
     * @param buffer
     * @param len
     * @return
     */
    private static byte[] decodeBytes( ByteBuffer buffer, int len )
    {
        byte[] bytes = new byte[len];
        buffer.get( bytes );
        return bytes;
    }


    /**
     * @param buffer
     * @return
     */
    private static String decodeString( ByteBuffer buffer, int len )
    {
        byte[] bytes = new byte[len];
        buffer.get( bytes );

        // find zero-terminator
        int slen = 0;

        while ( bytes[slen] != 0 )
        {
            slen++;
        }

        try
        {
            return new String( bytes, 0, slen, "ASCII" );
        }
        catch ( UnsupportedEncodingException e )
        {
            throw new RuntimeException( I18n.err( I18n.ERR_635 ), e );
        }
    }


    /**
     * Read a 4-byte inet address from the buffer.
     * 
     * @param buffer
     * @return
     * @throws UnknownHostException
     */
    private static InetAddress decodeAddress( ByteBuffer buffer )
    {
        byte[] addr = new byte[4];
        buffer.get( addr );

        try
        {
            return InetAddress.getByAddress( addr );
        }
        catch ( UnknownHostException e )
        {
            // should not happen
            return null;
        }
    }

    private static final byte[] VENDOR_MAGIC_COOKIE =
        { ( byte ) 99, ( byte ) 130, ( byte ) 83, ( byte ) 99 };


    public OptionsField decodeOptions( ByteBuffer message ) throws DhcpException
    {
        byte[] magicCookie = new byte[4];
        message.get( magicCookie );

        if ( !Arrays.equals( VENDOR_MAGIC_COOKIE, magicCookie ) )
        {
            throw new DhcpException( "Parse exception." );
        }

        byte code;
        byte length;
        byte[] value;

        OptionsField options = new OptionsField();

        while ( true )
        {
            code = message.get();

            if ( code == 0 ) // pad option
            {
                continue;
            }

            if ( code == -1 ) // end option
            {
                break;
            }

            length = message.get();
            value = new byte[length];
            message.get( value );

            options.add( getOptionInstance( code, value ) );
        }

        return options;
    }


    private DhcpOption getOptionInstance( int tag, byte[] value ) throws DhcpException
    {
        try
        {
            Class c = DhcpOption.getClassByTag( tag );

            DhcpOption o = null != c ? ( DhcpOption ) c.newInstance() : new UnrecognizedOption( ( byte ) tag );
            o.setData( value );

            return o;
        }
        catch ( Exception e )
        {
            throw new DhcpException( I18n.err( I18n.ERR_636, e.toString() ) );
        }
    }
}