pub fn validate_address_fedex(
    fedex_settings: FedexSettings,
    va: ValidateFedexAddresses,
    test: bool,
) -> AddressValidationResult {
    let (c_key, c_pass) = if !test {
        (
            fedex_settings.credential_key,
            fedex_settings.credential_pass,
        )
    } else {
        (
            fedex_settings.test_credential_key,
            fedex_settings.test_credential_pass,
        )
    };

    let mut uc = ns2__WebAuthenticationCredential {
        Key: str_as_mut_ptr!(c_key),
        Password: str_as_mut_ptr!(c_pass),
    };

    let mut wad = ns2__WebAuthenticationDetail {
        ParentCredential: null_mut_ptr!(ns2__WebAuthenticationCredential),
        UserCredential: item_as_mut_ptr!(uc, ns2__WebAuthenticationCredential),
    };

    let (an, mn) = if !test {
        (fedex_settings.accountnumber, fedex_settings.meternumber)
    } else {
        (
            fedex_settings.test_accountnumber,
            fedex_settings.test_meternumber,
        )
    };

    let mut cd = ns2__ClientDetail {
        AccountNumber: str_as_mut_ptr!(an),
        MeterNumber: str_as_mut_ptr!(mn),
        IntegratorId: null_mut_ptr!(i8),
        Localization: null_mut_ptr!(ns2__Localization),
    };

    let now = Utc::now();
    let mut seconds: i64 = now.timestamp() as i64; // NOTE: diff for windows

    let mut td = ns2__TransactionDetail {
        CustomerTransactionId: str_as_mut_ptr!("Address Validation Request"),
        Localization: null_mut_ptr!(ns2__Localization),
    };

    let mut v = ns2__VersionId {
        ServiceId: str_as_mut_ptr!("aval"),
        Major: 4 as libc::c_int,
        Intermediate: 0 as libc::c_int,
        Minor: 0 as libc::c_int,
    };

    let mut adrs = vec![];
    for address in va.addresses.into_iter() {
        let street_lines_len = address.street_lines.len();
        let mut street_lines = vec![];

        for sl in address.street_lines.into_iter() {
            street_lines.push(str_as_mut_ptr!(sl));
        }

        let state_or_province_code = match address.state_or_province_code {
            Some(_state_or_province_code) => str_as_mut_ptr!(_state_or_province_code),
            None => str_as_mut_ptr!("".to_owned()),
        };

        let urbanization_code = match address.urbanization_code {
            Some(_urbanization_code) => str_as_mut_ptr!(_urbanization_code),
            None => str_as_mut_ptr!("".to_owned()),
        };

        let country_name = match address.country_name {
            Some(_country_name) => str_as_mut_ptr!(_country_name),
            None => str_as_mut_ptr!("".to_owned()),
        };

        let mut adr = ns2__Address {
            __sizeStreetLines: street_lines_len as libc::c_int,
            StreetLines: street_lines.as_mut_ptr(),
            City: str_as_mut_ptr!(address.city),
            StateOrProvinceCode: state_or_province_code,
            PostalCode: str_as_mut_ptr!(address.postal_code),
            UrbanizationCode: urbanization_code,
            CountryCode: str_as_mut_ptr!(address.country_code),
            CountryName: country_name,
            Residential: null_mut_ptr!(xsd__boolean), // NOTE: some day, if needed
        };

        std::mem::forget(street_lines);

        adrs.push(ns2__AddressToValidate {
            ClientReferenceId: str_as_mut_ptr!(address.reference_id),
            Contact: null_mut_ptr!(ns2__Contact),
            Address: item_as_mut_ptr!(adr, ns2__Address),
        });
    }

    let addrsss_ptr = ptr_mut_array!(adrs, ns2__AddressToValidate);

    for i in 0..adrs.len() {
        unsafe { addrsss_ptr.offset(i as isize).write(adrs[i]) };
    }

    let mut vr = ns2__AddressValidationRequest {
        WebAuthenticationDetail: item_as_mut_ptr!(wad, ns2__WebAuthenticationDetail),
        ClientDetail: item_as_mut_ptr!(cd, ns2__ClientDetail),
        InEffectAsOfTimestamp: item_as_mut_ptr!(seconds, ::std::os::raw::c_long),
        TransactionDetail: item_as_mut_ptr!(td, ns2__TransactionDetail),
        Version: item_as_mut_ptr!(v, ns2__VersionId),
        __sizeAddressesToValidate: adrs.len() as libc::c_int,
        AddressesToValidate: addrsss_ptr as *mut ns2__AddressToValidate,
    };

    let vt_ptr = item_as_mut_ptr!(vr, ns2__AddressValidationRequest);
    std::mem::forget(vr);

    let soap = unsafe { create_soap() };

    let base_url = if !test {
        fedex_settings.url
    } else {
        fedex_settings.test_url
    };

    let output: ns2__AddressValidationReply =
        unsafe { validate_address(soap, CString::new(base_url).unwrap().as_ptr(), vt_ptr) };

    let mut result_data: Vec<AddressValidationResultData> = vec![];

    for address_results_offset in 0..output.__sizeAddressResults {
        let address_results = unsafe {
            *output
                .AddressResults
                .offset(address_results_offset as isize)
        };

        let size_attributes = address_results.__sizeAttributes;
        let mut attributes_map: HashMap<String, String> = HashMap::new();

        for size_attributes_offset in 0..size_attributes {
            let attributes = unsafe {
                *address_results
                    .Attributes
                    .offset(size_attributes_offset as isize)
            };
            let name = attributes.Name;
            let value = attributes.Value;
            attributes_map.insert(
                ptr_as_str!(name).to_owned().to_camel_case(),
                ptr_as_str!(value).to_owned(),
            );
        }

        let client_reference_id = address_results.ClientReferenceId;

        let r_state = if !address_results.State.is_null() {
            unsafe { (*address_results.State) }.clone()
        } else {
            999 as u32
        };

        //println!("\nr_state = {:?}", r_state);

        #[allow(non_upper_case_globals)]
        let state = match r_state {
            ns2__OperationalAddressStateType_ns2__OperationalAddressStateType__NORMALIZED => {
                "NORMALIZED".to_owned()
            }
            ns2__OperationalAddressStateType_ns2__OperationalAddressStateType__RAW => {
                "RAW".to_owned()
            }
            ns2__OperationalAddressStateType_ns2__OperationalAddressStateType__STANDARDIZED => {
                "STANDARDIZED".to_owned()
            }
            _ => "UNKNOWN".to_owned(),
        };

        let r_classification = if !address_results.Classification.is_null() {
            unsafe { (*address_results.Classification) }.clone()
        } else {
            999 as u32
        };

        //println!("\r_classification = {:?}", r_state);

        #[allow(non_upper_case_globals)]
        let classification = match r_classification {
            ns2__FedExAddressClassificationType_ns2__FedExAddressClassificationType__BUSINESS => {
                "BUSINESS".to_owned()
            }
            ns2__FedExAddressClassificationType_ns2__FedExAddressClassificationType__MIXED => {
                "MIXED".to_owned()
            }
            ns2__FedExAddressClassificationType_ns2__FedExAddressClassificationType__RESIDENTIAL => {
                "RESIDENTIAL".to_owned()
            }
            _ => "UNKNOWN".to_owned(),
        };

        let effective_address_ptr = unsafe { *address_results.EffectiveAddress };
        let mut ea_street_lines: Vec<String> = vec![];

        for ea_street_line_offset in 0..effective_address_ptr.__sizeStreetLines {
            let steet_line_ptr = unsafe {
                *effective_address_ptr
                    .StreetLines
                    .offset(ea_street_line_offset as isize)
            };
            let steet_line_str = ptr_as_str!(steet_line_ptr).to_owned();
            ea_street_lines.push(steet_line_str);
        }

        let effective_address = EffectiveAddress {
            street_lines: ea_street_lines,
            city: ptr_as_op_string!(effective_address_ptr.City),
            state_or_province_code: ptr_as_op_string!(effective_address_ptr.StateOrProvinceCode),
            postal_code: ptr_as_op_string!(effective_address_ptr.PostalCode),
            urbanization_code: ptr_as_op_string!(effective_address_ptr.UrbanizationCode),
            country_code: ptr_as_op_string!(effective_address_ptr.CountryCode),
            country_name: ptr_as_op_string!(effective_address_ptr.CountryName),
            residential: ptr_as_op!(effective_address_ptr.Residential),
        };

        result_data.push({
            AddressValidationResultData {
                client_reference_id: ptr_as_str!(client_reference_id).to_owned(),
                state: state,
                classification: classification,
                attributes: attributes_map,
                effective_address: effective_address,
            }
        });

        break;
    }

    let message = if output.Notifications.is_null() {
        "Connection failed! Please check 'URL' and contact support in necessary.".to_owned()
    } else {
        ptr_as_str!((*output.Notifications).Message).to_owned()
    };

    #[allow(non_upper_case_globals)]
    let status = match output.HighestSeverity {
        ns1__NotificationSeverityType_ns1__NotificationSeverityType__ERROR => "ERROR".to_owned(),
        ns1__NotificationSeverityType_ns1__NotificationSeverityType__FAILURE => {
            "FAILURE".to_owned()
        }
        ns1__NotificationSeverityType_ns1__NotificationSeverityType__NOTE => "NOTE".to_owned(),
        ns1__NotificationSeverityType_ns1__NotificationSeverityType__SUCCESS => {
            "SUCCESS".to_owned()
        }
        ns1__NotificationSeverityType_ns1__NotificationSeverityType__WARNING => {
            "WARNING".to_owned()
        }
        _ => "FAILURE".to_owned(),
    };

    unsafe { free_soap(soap) };

    //println!("output.HighestSeverity = {:?}", output.HighestSeverity);

    AddressValidationResult {
        status: status,
        status_code: output.HighestSeverity,
        message: message,
        data: result_data,
    }
}