/*
* Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of the License "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description:  Statemachine for establishing an adhoc network
*
*/


#include "core_sub_operation_adhoc.h"
#include "core_tx_rate_policies.h"
#include "core_frame_dot11.h"
#include "core_server.h"
#include "core_tools.h"
#include "am_debug.h"

/** The channel definition for automatic channel selection. */
const u32_t AUTOMATIC_CHANNEL = 0;

const u32_t CH_WEIGHT_1       = 4;
const u32_t CH_WEIGHT_2       = 2;
const u32_t CH_WEIGHT_3       = 1;

// ======== MEMBER FUNCTIONS ========

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
//
core_sub_operation_adhoc_c::core_sub_operation_adhoc_c(
    u32_t request_id,
    core_server_c* server,
    abs_core_driverif_c* drivers,
    abs_core_server_callback_c* adaptation,
    core_ap_data_c** ap_data ) :
    core_operation_base_c( core_operation_unspecified, request_id, server, drivers, adaptation,
        core_base_flag_drivers_needed ),
    ptr_ap_data_m( ap_data ),
    channel_m( 0 )
    {
    DEBUG( "core_sub_operation_adhoc_c::core_sub_operation_adhoc_c()" );
    }

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
//
core_sub_operation_adhoc_c::~core_sub_operation_adhoc_c()
    {
    DEBUG( "core_sub_operation_adhoc_c::~core_sub_operation_adhoc_c()" );

    server_m->unregister_event_handler( this );
    server_m->unregister_frame_handler( this );
    ptr_ap_data_m = NULL;
    }

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
//
core_error_e core_sub_operation_adhoc_c::next_state()
    {
    DEBUG( "core_sub_operation_adhoc_c::next_state()" );

    switch ( operation_state_m )
        {
        case core_state_init:
            {
            core_tools_c::fillz(
                &noise_per_channel_m[0],
                SCAN_BAND_2DOT4GHZ_MAX_CHANNEL_EURO * sizeof( u32_t ) );            

            core_iap_data_c* iap = &(server_m->get_connection_data()->iap_data());
            ASSERT( iap->adhoc_channel() <= SCAN_BAND_2DOT4GHZ_MAX_CHANNEL_FCC ); // FCC limitations: no ch 12 or 13
            ASSERT( iap->ssid().length );
            ASSERT( iap->ssid().length <= MAX_SSID_LEN );
            ASSERT( iap->security_mode() == core_security_mode_allow_unsecure ||
                    iap->security_mode() == core_security_mode_wep );

            channel_m = iap->adhoc_channel();
            if ( channel_m != AUTOMATIC_CHANNEL )
                {
                return goto_state( core_state_req_set_tx_rate_policies );
                }

            /**
             * Do a broadcast scan to detect the channel with least traffic.
             */
            operation_state_m = core_state_scan_start;

            server_m->get_scan_list().remove_entries_by_age(
                server_m->get_device_settings().scan_list_expiration_time );

            server_m->register_event_handler( this );
            server_m->register_frame_handler( this );

            drivers_m->scan(
                request_id_m,
                core_scan_mode_passive,
                BROADCAST_SSID,
                server_m->get_device_settings().scan_rate,
                server_m->get_core_settings().all_valid_scan_channels(),
                server_m->get_device_settings().passive_scan_min_ch_time,
                server_m->get_device_settings().passive_scan_max_ch_time,
                false_t );

            break;    
            }
        case core_state_scan_start:
            {
            DEBUG( "core_sub_operation_adhoc_c::next_state() - scan request completed, waiting for scan completion" );

            break;
            }            
        case core_state_scan_complete:
            {
            server_m->unregister_frame_handler( this );

            DEBUG( "core_sub_operation_adhoc_c::next_state() - selecting channel with least noise" );

            /**
             * All channels are now checked and the noise marked.
             * Now, we have to found the smallest noise.
             */
            u32_t tmp_best_noise( 0xFFFFFFFF );
            u8_t tmp_best_channel( 0 );
            for ( u8_t idx = 0; idx < SCAN_BAND_2DOT4GHZ_MAX_CHANNEL_FCC; ++idx ) // Only ch 1 - 11
                {
                DEBUG2( "core_sub_operation_adhoc_c::next_state() - NoiseTable[%u] = %u",
                    idx, noise_per_channel_m[idx] );
                if ( noise_per_channel_m[idx] < tmp_best_noise )
                    {
                    tmp_best_noise = noise_per_channel_m[idx];
                    tmp_best_channel = idx;
                    }
                }
            channel_m = tmp_best_channel + 1;
            DEBUG1( "core_sub_operation_adhoc_c::next_state() - channel %u selected",
                channel_m );

            return goto_state( core_state_req_set_tx_rate_policies );
            }
        case core_state_req_set_tx_rate_policies:
            {
            operation_state_m = core_state_req_start_adhoc;

            core_tx_rate_policies_s policies;
            core_tx_rate_policy_mappings_s mappings;

            if ( server_m->get_core_settings().is_bt_connection_established() )
                {
                DEBUG( "core_sub_operation_adhoc_c::next_state() - using 802.11bg BT TX rate policy" );

                policies.policy_count = 1;
                policies.policy[0] = TX_RATE_POLICY_BLUETOOTH_BG;
                mappings.policy_for_best_effort = 0;
                mappings.policy_for_background = 0;
                mappings.policy_for_video = 0;
                mappings.policy_for_voice = 0;                
                }
            else
                {
                DEBUG( "core_sub_operation_adhoc_c::next_state() - using 802.11bg default and voice TX rate policy" );

                policies.policy_count = 2;
                policies.policy[0] = TX_RATE_POLICY_BG;
                policies.policy[1] = TX_RATE_POLICY_VOICE_BG;
                mappings.policy_for_best_effort = 0;
                mappings.policy_for_background = 0;
                mappings.policy_for_video = 0;
                mappings.policy_for_voice = 1;           
                }

            /**
             * Fill in the default retry limits if not overridden by the policy.
             */
            for ( u8_t idx( 0 ); idx < policies.policy_count; ++idx )
                {
                if ( !policies.policy[idx].short_retry_limit )
                    {
                    policies.policy[idx].short_retry_limit =
                        server_m->get_device_settings().short_retry;
                    }
                if ( ! policies.policy[idx].long_retry_limit )
                    {
                    policies.policy[idx].long_retry_limit =
                        server_m->get_device_settings().long_retry;
                    }
                }

            DEBUG( "core_sub_operation_adhoc_c::next_state() - setting TX rate policies" );

            drivers_m->set_tx_rate_policies(
                request_id_m,
                policies,
                mappings );

            break;
            }            
        case core_state_req_start_adhoc:
            {
            DEBUG( "core_sub_operation_adhoc_c::next_state() - TX rate policies set" );

            operation_state_m = core_state_adhoc_started;

            core_encryption_mode_e encryption_mode = core_encryption_mode_disabled;            
            if( server_m->get_connection_data()->iap_data().security_mode() ==
                core_security_mode_wep )
                {
                encryption_mode = core_encryption_mode_wep;
                }

            DEBUG1( "core_sub_operation_adhoc_c::next_state() - starting the adhoc on channel %u",
                channel_m );

            server_m->register_frame_handler( this );

            drivers_m->start_ibss(
                request_id_m,
                server_m->get_connection_data()->iap_data().ssid(),
                server_m->get_device_settings().beacon,
                channel_m,
                encryption_mode );

            break;    
            }
        case core_state_adhoc_started:
            {
            /**
             * If our own beacon has already been received, proceed to the
             * next state.
             */            
            if( *ptr_ap_data_m )
                {
                return goto_state( core_state_adhoc_complete );
                }
            
            return goto_state( core_state_adhoc_frame );
            }
        case core_state_adhoc_frame:
            {
            DEBUG( "core_sub_operation_adhoc_c::next_state() - waiting for beacon frame" );

            break;
            }
        case core_state_adhoc_complete:
            {
            server_m->unregister_frame_handler( this );

            DEBUG( "core_sub_operation_adhoc_c::next_state() - all done" );           

            return core_error_ok;
            }
        default:
            {
            ASSERT( false_t );
            }          
        }

    return core_error_request_pending;
    }

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
//
core_error_e core_sub_operation_adhoc_c::cancel()
    {
    DEBUG( "core_sub_operation_adhoc_c::cancel() " );    
    
    switch ( operation_state_m )
        {              
        case core_state_adhoc_started:
            {
            /** The connection attempt failed, we are no longer connected. */
            return next_state();
            }
        default:
            {
            return failure_reason_m;
            }
        }    
    }

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
//
void core_sub_operation_adhoc_c::user_cancel(
    bool_t do_graceful_cancel )
    {
    DEBUG( "core_sub_operation_adhoc_c::user_cancel()" );

    if ( !do_graceful_cancel )
        {
        /**
         * If we are in a middle of a scan, we have to schedule our own
         * event.
         */
        if ( operation_state_m == core_state_scan_start &&
             server_m->event_handler() == this &&
             server_m->frame_handler() == this )         
            {
            asynch_default_user_cancel();
    
            return;
            }

        /**
         * If we are waiting for a beacon, we have to schedule our own
         * event.
         */
        if ( operation_state_m == core_state_adhoc_frame )
            {
            asynch_default_user_cancel();
    
            return;            
            }

        /**
         * Everything else is handled by the default implementation.
         */
        core_operation_base_c::user_cancel( do_graceful_cancel );
        }
    }

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
//    
bool_t core_sub_operation_adhoc_c::receive_frame(
    const core_frame_dot11_c* frame,
    u8_t rcpi )
    {
    DEBUG( "core_sub_operation_adhoc_c::receive_frame()" );
    
    if ( frame->type() != core_frame_dot11_c::core_dot11_type_beacon &&
         frame->type() != core_frame_dot11_c::core_dot11_type_probe_resp )
        {
        DEBUG( "core_sub_operation_adhoc_c::receive_frame() - not a beacon or a probe" );        
        return false_t;
        }

    core_ap_data_c* ap_data = core_ap_data_c::instance(
        server_m->get_wpx_adaptation_instance(),
        frame,
        rcpi,
        true_t );
    if ( ap_data )
        {
        server_m->get_scan_list().update_entry( *ap_data );

        if ( operation_state_m == core_state_scan_start )
            {
            u8_t channel = ap_data->channel();
            DEBUG1( "core_sub_operation_adhoc_c::next_state() - AP in channel %u",
                channel );
        
            if ( channel && channel <= SCAN_BAND_2DOT4GHZ_MAX_CHANNEL_EURO )
                {
                /**
                 * Add the ch table as follows:
                 * channel of the AP ==> increase by CH_WEIGHT_1
                 * channels +-1 ==> increase by CH_WEIGHT_2
                 * channels +-2 ==> increase by CH_WEIGHT_3
                 *
                 * Note that the legal channels are 1 - 13 BUT the
                 * array is 0 - 12! Beware edges!
                 */
                noise_per_channel_m[channel - 1] += CH_WEIGHT_1;
                if ( channel > 1 )
                    {
                    noise_per_channel_m[channel - 2] += CH_WEIGHT_2;
                    }
                if ( channel > 2)
                    {
                    noise_per_channel_m[channel - 3] += CH_WEIGHT_3;
                    }
                if ( channel < SCAN_BAND_2DOT4GHZ_MAX_CHANNEL_EURO -2 )
                    {
                    noise_per_channel_m[channel] += CH_WEIGHT_2;
                    }
                if ( channel < SCAN_BAND_2DOT4GHZ_MAX_CHANNEL_EURO -3 )
                    {
                    noise_per_channel_m[channel + 1] += CH_WEIGHT_3;
                    }
                }           
            }
        else if ( operation_state_m == core_state_adhoc_started ||
            operation_state_m == core_state_adhoc_frame )
            {
            if ( frame->type() == core_frame_dot11_c::core_dot11_type_beacon )
                {
                DEBUG( "core_sub_operation_adhoc_c::next_state() - beacon received" );

                ASSERT( !ap_data->is_infra() );
                ASSERT( !*ptr_ap_data_m );

                *ptr_ap_data_m = ap_data;

                /**
                 * If we are just waiting for the beacon frame, we have to schedule
                 * our own timer to proceed.
                 */
                if( operation_state_m == core_state_adhoc_frame )
                    {
                    asynch_goto( core_state_adhoc_complete, CORE_TIMER_IMMEDIATELY );
                    }

                return true_t;
                }
            }

        delete ap_data;
        ap_data = NULL;
        }    

    return true_t;
    }


// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
//
bool_t core_sub_operation_adhoc_c::notify(
    core_am_indication_e indication )
    {
    if ( operation_state_m == core_state_scan_start &&
         indication == core_am_indication_wlan_scan_complete )
        {
        server_m->unregister_event_handler( this );

        DEBUG( "core_sub_operation_adhoc_c::notify() - scan complete" );

        asynch_goto( core_state_scan_complete, CORE_TIMER_IMMEDIATELY );

        return true_t;
        }

    return false_t;
    }