Summarize this function: def format_json_validation_result(
    validation_result: ExpectationValidationResult,
    busn_line_nm: str,
    input_file_short: str,
    error_type: str,
    ingst_dt: str,
    input_file_long: str,
    meta: dict,
    distinct_bad_agis: bool = False, # pragma: no mutate
    df: DataFrame = None,
    ix_keys: list = None,
    event_id = None
) -> dict:
    """Formats the results from Greater Exepectations into dictionary used for making JSONs

    Parameters
    ----------
    validation_result
        Greater Expectations Expectation Validation Result
    busn_line_nm
        auto, fire
    input_file_short
        The shortened name
    error_type
        The type of error
    ingst_dt
        The date of ingestion
    input_file_long
        The full name
    meta
        contains information about expectation criteria, rule numbers, and potentially error types
    df
        dataframe in which data quality if being performed on
    ix_keys
        index keys used to fetch bad records
    event_id
        event id used for data quality
    Returns
    -------
    dict
        Formatted JSON
    """
    if validation_result.success:
        return {}
    else:
        result_dict = validation_result.result
        config_dict = validation_result.expectation_config
        is_success = validation_result.success # pragma: no mutate (mutation testing sets this to Null which is equal to False.  It will always be False)
        unexpected_count = partial_unexpected_list = element_count = not_null_count = unexpected_percent = "N/A"
        if "unexpected_count" in result_dict.keys():
            unexpected_count = result_dict["unexpected_count"]
        if "partial_unexpected_list" in result_dict.keys():
            partial_unexpected_list = result_dict["partial_unexpected_list"]
        if "element_count" in result_dict.keys():
            element_count = result_dict["element_count"]
            if "missing_count" in result_dict.keys(): 
                missing_count = result_dict["missing_count"] 
                not_null_count = element_count -missing_count 
            else: 
                not_null_count = element_count 
        if "unexpected_percent" in result_dict.keys():
            unexpected_percent = result_dict["unexpected_percent"]
        k1 = [
            "validation_name",
            "validation_field",
            "meta",
            "busn_line_nm",
            "input_file_short",
            "ingst_dt",
            "error_type",
            "error_count",
            "total_count",
            "not_null_count",
            "error_percent",
            "input_file_long",
            "other_arguments",
        ]
        v1 = [
            config_dict["expectation_type"],
            get_col_name(config_dict["kwargs"]),
            meta,
            busn_line_nm,
            input_file_short,
            ingst_dt,
            error_type,
            unexpected_count,
            element_count,
            not_null_count,
            unexpected_percent,
            input_file_long,
            config_dict["kwargs"],
        ]
        # Include observed type if expect_column_values_to_be_of_type is unexpected
        if "observed_value" in result_dict:
            if not is_success:
                if config_dict.expectation_type == "expect_column_values_to_be_of_type":
                    observed_value = result_dict["observed_value"]
                    k1.append("observed_type")
                    v1.append(observed_value)
        k1 = tuple(k1)
        v1 = tuple(v1)
        if ix_keys:
            if df is not None:
                bad_values = [] # pragma: no mutate
                bad_rows_key_values = [] # pragma: no mutate
                if partial_unexpected_list != "N/A":  # pragma: no mutate
                    if config_dict.expectation_type == "expect_column_values_to_not_be_null" and config_dict["kwargs"]["column"] in df.columns:

                        bad_rows_key_values = get_ix_values(
                        df, config_dict["kwargs"]["column"], ix_keys, distinct_bad_agis)
                        bad_values = ['null']
                    
                    elif "column" in config_dict["kwargs"] and config_dict["kwargs"]["column"] in df.columns:
                        bad_rows_key_values = get_ix_values(
                        df,
                        config_dict["kwargs"]["column"],
                        ix_keys,
                        distinct_bad_agis,
                        bad_values=partial_unexpected_list,
                    )
                        bad_values = partial_unexpected_list
                        bad_values = sorted(list(set(bad_values)))

                    elif "column_A" in config_dict["kwargs"] and "column_B" in config_dict["kwargs"]:  # pragma: no mutate
                        if config_dict["kwargs"]["column_A"] in df.columns and config_dict["kwargs"]["column_B"] in df.columns:  # pragma: no mutate
                            bad_values_dict = get_ix_values_pair(df, config_dict, ix_keys, distinct_bad_agis)
                            bad_rows_key_values = bad_values_dict["ix_keys"]
                            bad_values = bad_values_dict["bad_values"]
                    else:
                        bad_rows_key_values = None  # pragma: no mutate
                        bad_values = None  # pragma: no mutate

                k2 = list(k1)
                k2.append("bad_values")
                k2.append("bad_rows_key")
                k2.append("bad_rows_key_values")
                v2 = list(v1)
                v2.append(bad_values)
                v2.append(ix_keys)
                v2.append(bad_rows_key_values)
                k1 = tuple(k2)
                v1 = tuple(v2)
        return_dict = {k: v for k, v in zip(k1, v1)}
    return return_dict