use super::api_descriptor::{get_wire_type, is_map, make_tag};
use crate::base::status::Status;
use crate::serial::api_descriptor::{is_array, ServiceApiDescriptor};
use protobuf::descriptor::field_descriptor_proto::Type;
use protobuf::descriptor::FieldDescriptorProto;
use protobuf::CodedOutputStream;
use serde_json::Value;

// bool
fn compute_one_bool_size(field: &FieldDescriptorProto, json_value: &Value) -> Result<u64, Status> {
    if !json_value.is_boolean() {
        return Err(Status::error(format!(
            "{} 类型错误！",
            field.name.as_ref().unwrap()
        )));
    }
    let value = json_value.as_bool().unwrap();
    if value == false {
        return Ok(0);
    }

    return Ok(2 + 1);
}

fn compute_bool_size(field: &FieldDescriptorProto, json_value: &Value) -> Result<u64, Status> {
    let mut size = 0;
    if is_array(field) {
        if !json_value.is_array() {
            return Err(Status::error(format!(
                "{} 类型错误, 应为数组！",
                field.name.as_ref().unwrap()
            )));
        }
        for ele in json_value.as_array().unwrap() {
            size += compute_one_bool_size(field, ele)?;
        }
        Ok(size)
    } else {
        compute_one_bool_size(field, json_value)
    }
}

fn write_one_bool(
    field: &FieldDescriptorProto,
    json_value: &Value,
    output_stream: &mut CodedOutputStream,
) -> Result<(), Status> {
    let number = field.number.unwrap() as u32;
    let value = json_value.as_bool().unwrap();
    if value == false {
        return Ok(());
    }
    let result = output_stream.write_bool(number, value);
    if result.is_err() {
        return Err(Status::error(format!(
            "{} 序列化失败！",
            field.name.as_ref().unwrap()
        )));
    }
    Ok(())
}

//
fn write_bool(
    field: &FieldDescriptorProto,
    json_value: &Value,
    output_stream: &mut CodedOutputStream,
) -> Result<(), Status> {
    if is_array(field) {
        for ele in json_value.as_array().unwrap() {
            write_one_bool(field, ele, output_stream)?;
        }
        Ok(())
    } else {
        write_one_bool(field, json_value, output_stream)
    }
}

// float

fn compute_one_float_size(field: &FieldDescriptorProto, json_value: &Value) -> Result<u64, Status> {
    if !json_value.is_f64() {
        return Err(Status::error(format!(
            "{} 类型错误！",
            field.name.as_ref().unwrap()
        )));
    }
    let value = json_value.as_f64().unwrap();
    if value == 0.0 {
        return Ok(0);
    }
    return Ok(1 + 4);
}

fn compute_float_size(field: &FieldDescriptorProto, json_value: &Value) -> Result<u64, Status> {
    let mut size = 0;
    if is_array(field) {
        if !json_value.is_array() {
            return Err(Status::error(format!(
                "{} 类型错误, 应为数组！",
                field.name.as_ref().unwrap()
            )));
        }
        for ele in json_value.as_array().unwrap() {
            size += compute_one_float_size(field, ele)?;
        }
        Ok(size)
    } else {
        compute_one_float_size(field, json_value)
    }
}

fn write_one_float(
    field: &FieldDescriptorProto,
    json_value: &Value,
    output_stream: &mut CodedOutputStream,
) -> Result<(), Status> {
    let number = field.number.unwrap() as u32;
    let value = json_value.as_f64().unwrap();
    if value == 0.0 {
        return Ok(());
    }
    let result = output_stream.write_float(number, value as f32);
    if result.is_err() {
        return Err(Status::error(format!(
            "{} 序列化失败！",
            field.name.as_ref().unwrap()
        )));
    }
    Ok(())
}

//
fn write_float(
    field: &FieldDescriptorProto,
    json_value: &Value,
    output_stream: &mut CodedOutputStream,
) -> Result<(), Status> {
    if is_array(field) {
        for ele in json_value.as_array().unwrap() {
            write_one_float(field, ele, output_stream)?;
        }
        Ok(())
    } else {
        write_one_float(field, json_value, output_stream)
    }
}

fn compute_one_double_size(
    field: &FieldDescriptorProto,
    json_value: &Value,
) -> Result<u64, Status> {
    if !json_value.is_f64() {
        return Err(Status::error(format!(
            "{} 类型错误！",
            field.name.as_ref().unwrap()
        )));
    }
    let value = json_value.as_f64().unwrap();
    if value == 0.0 {
        return Ok(0);
    }
    return Ok(1 + 8);
}

fn compute_double_size(field: &FieldDescriptorProto, json_value: &Value) -> Result<u64, Status> {
    let mut size = 0;
    if is_array(field) {
        if !json_value.is_array() {
            return Err(Status::error(format!(
                "{} 类型错误, 应为数组！",
                field.name.as_ref().unwrap()
            )));
        }
        for ele in json_value.as_array().unwrap() {
            size += compute_one_double_size(field, ele)?;
        }
        Ok(size)
    } else {
        compute_one_double_size(field, json_value)
    }
}

// double
fn write_one_double(
    field: &FieldDescriptorProto,
    json_value: &Value,
    output_stream: &mut CodedOutputStream,
) -> Result<(), Status> {
    let number = field.number.unwrap() as u32;
    let value = json_value.as_f64().unwrap();
    if value == 0.0 {
        return Ok(());
    }
    let result = output_stream.write_double(number, value);
    if result.is_err() {
        return Err(Status::error(format!(
            "{} 序列化失败！",
            field.name.as_ref().unwrap()
        )));
    }
    Ok(())
}

//
fn write_double(
    field: &FieldDescriptorProto,
    json_value: &Value,
    output_stream: &mut CodedOutputStream,
) -> Result<(), Status> {
    if is_array(field) {
        for ele in json_value.as_array().unwrap() {
            write_one_double(field, ele, output_stream)?;
        }
        Ok(())
    } else {
        write_one_double(field, json_value, output_stream)
    }
}

fn compute_one_sint64_size(
    field: &FieldDescriptorProto,
    json_value: &Value,
) -> Result<u64, Status> {
    let number = field.number.unwrap() as u32;
    if !json_value.is_i64() {
        return Err(Status::error(format!(
            "{} 类型错误！",
            field.name.as_ref().unwrap()
        )));
    }
    let value = json_value.as_i64().unwrap();
    if value == 0 {
        return Ok(0);
    }
    return Ok(protobuf::rt::sint64_size(number, value));
}

fn compute_sint64_size(field: &FieldDescriptorProto, json_value: &Value) -> Result<u64, Status> {
    let mut size = 0;

    if is_array(field) {
        if !json_value.is_array() {
            return Err(Status::error(format!(
                "{} 类型错误, 应为数组！",
                field.name.as_ref().unwrap()
            )));
        }
        for ele in json_value.as_array().unwrap() {
            size += compute_one_sint64_size(field, ele)?;
        }
        Ok(size)
    } else {
        compute_one_sint64_size(field, json_value)
    }
}

// sint64
fn write_one_sint64(
    field: &FieldDescriptorProto,
    json_value: &Value,
    output_stream: &mut CodedOutputStream,
) -> Result<(), Status> {
    let number = field.number.unwrap() as u32;
    let value = json_value.as_i64().unwrap();
    if value == 0 {
        return Ok(());
    }
    let result = output_stream.write_sint64(number, value);
    if result.is_err() {
        return Err(Status::error(format!(
            "{} 序列化失败！",
            field.name.as_ref().unwrap()
        )));
    }
    Ok(())
}

//
fn write_sint64(
    field: &FieldDescriptorProto,
    json_value: &Value,
    output_stream: &mut CodedOutputStream,
) -> Result<(), Status> {
    if is_array(field) {
        for ele in json_value.as_array().unwrap() {
            write_one_sint64(field, ele, output_stream)?;
        }
        Ok(())
    } else {
        write_one_sint64(field, json_value, output_stream)
    }
}

//
fn compute_one_sint32_size(
    field: &FieldDescriptorProto,
    json_value: &Value,
) -> Result<u64, Status> {
    let number = field.number.unwrap() as u32;
    if !json_value.is_i64() {
        return Err(Status::error(format!(
            "{} 类型错误！",
            field.name.as_ref().unwrap()
        )));
    }
    let value = json_value.as_i64().unwrap();
    if value == 0 {
        return Ok(0);
    }
    return Ok(protobuf::rt::sint32_size(number, value as i32));
}

fn compute_sint32_size(field: &FieldDescriptorProto, json_value: &Value) -> Result<u64, Status> {
    let mut size = 0;
    if is_array(field) {
        if !json_value.is_array() {
            return Err(Status::error(format!(
                "{} 类型错误, 应为数组！",
                field.name.as_ref().unwrap()
            )));
        }
        for ele in json_value.as_array().unwrap() {
            size += compute_one_sint32_size(field, ele)?;
        }
        Ok(size)
    } else {
        compute_one_sint32_size(field, json_value)
    }
}

// sint32
fn write_one_sint32(
    field: &FieldDescriptorProto,
    json_value: &Value,
    output_stream: &mut CodedOutputStream,
) -> Result<(), Status> {
    let number = field.number.unwrap() as u32;
    let value = json_value.as_i64().unwrap();
    if value == 0 {
        return Ok(());
    }
    let result = output_stream.write_sint32(number, value as i32);
    if result.is_err() {
        return Err(Status::error(format!(
            "{} 序列化失败！",
            field.name.as_ref().unwrap()
        )));
    }
    Ok(())
}

//
fn write_sint32(
    field: &FieldDescriptorProto,
    json_value: &Value,
    output_stream: &mut CodedOutputStream,
) -> Result<(), Status> {
    if is_array(field) {
        for ele in json_value.as_array().unwrap() {
            write_one_sint32(field, ele, output_stream)?;
        }
        Ok(())
    } else {
        write_one_sint32(field, json_value, output_stream)
    }
}

//
fn compute_one_sfixed64_size(
    field: &FieldDescriptorProto,
    json_value: &Value,
) -> Result<u64, Status> {
    if !json_value.is_i64() {
        return Err(Status::error(format!(
            "{} 类型错误！",
            field.name.as_ref().unwrap()
        )));
    }

    let value = json_value.as_i64().unwrap();
    if value == 0 {
        return Ok(0);
    }
    return Ok(1 + 8);
}

fn compute_sfixed64_size(field: &FieldDescriptorProto, json_value: &Value) -> Result<u64, Status> {
    let mut size = 0;
    if is_array(field) {
        if !json_value.is_array() {
            return Err(Status::error(format!(
                "{} 类型错误, 应为数组！",
                field.name.as_ref().unwrap()
            )));
        }
        for ele in json_value.as_array().unwrap() {
            size += compute_one_sfixed64_size(field, ele)?;
        }
        Ok(size)
    } else {
        compute_one_sfixed64_size(field, json_value)
    }
}

// sfixed64
fn write_one_sfixed64(
    field: &FieldDescriptorProto,
    json_value: &Value,
    output_stream: &mut CodedOutputStream,
) -> Result<(), Status> {
    let number = field.number.unwrap() as u32;
    let value = json_value.as_i64().unwrap();
    if value == 0 {
        return Ok(());
    }
    let result = output_stream.write_sfixed64(number, value);
    if result.is_err() {
        return Err(Status::error(format!(
            "{} 序列化失败！",
            field.name.as_ref().unwrap()
        )));
    }
    Ok(())
}

//
fn write_sfixed64(
    field: &FieldDescriptorProto,
    json_value: &Value,
    output_stream: &mut CodedOutputStream,
) -> Result<(), Status> {
    if is_array(field) {
        for ele in json_value.as_array().unwrap() {
            write_one_sfixed64(field, ele, output_stream)?;
        }
        Ok(())
    } else {
        write_one_sfixed64(field, json_value, output_stream)
    }
}

//
fn compute_one_sfixed32_size(
    field: &FieldDescriptorProto,
    json_value: &Value,
) -> Result<u64, Status> {
    if !json_value.is_i64() {
        return Err(Status::error(format!(
            "{} 类型错误！",
            field.name.as_ref().unwrap()
        )));
    }
    let value = json_value.as_i64().unwrap();
    if value == 0 {
        return Ok(0);
    }
    return Ok(1 + 4);
}

fn compute_sfixed32_size(field: &FieldDescriptorProto, json_value: &Value) -> Result<u64, Status> {
    let mut size = 0;
    if is_array(field) {
        if !json_value.is_array() {
            return Err(Status::error(format!(
                "{} 类型错误, 应为数组！",
                field.name.as_ref().unwrap()
            )));
        }
        for ele in json_value.as_array().unwrap() {
            size += compute_one_sfixed32_size(field, ele)?;
        }
        Ok(size)
    } else {
        compute_one_sfixed32_size(field, json_value)
    }
}

// sfixed32
fn write_one_sfixed32(
    field: &FieldDescriptorProto,
    json_value: &Value,
    output_stream: &mut CodedOutputStream,
) -> Result<(), Status> {
    let number = field.number.unwrap() as u32;
    let value = json_value.as_i64().unwrap();
    if value == 0 {
        return Ok(());
    }
    let result = output_stream.write_sfixed32(number, value as i32);
    if result.is_err() {
        return Err(Status::error(format!(
            "{} 序列化失败！",
            field.name.as_ref().unwrap()
        )));
    }
    Ok(())
}

//
fn write_sfixed32(
    field: &FieldDescriptorProto,
    json_value: &Value,
    output_stream: &mut CodedOutputStream,
) -> Result<(), Status> {
    if is_array(field) {
        for ele in json_value.as_array().unwrap() {
            write_one_sfixed32(field, ele, output_stream)?;
        }
        Ok(())
    } else {
        write_one_sfixed32(field, json_value, output_stream)
    }
}

//
fn compute_one_enum_size(field: &FieldDescriptorProto, json_value: &Value) -> Result<u64, Status> {
    let number = field.number.unwrap() as u32;
    if !json_value.is_i64() {
        return Err(Status::error(format!(
            "{} 类型错误！",
            field.name.as_ref().unwrap()
        )));
    }
    let value = json_value.as_i64().unwrap();
    if value == 0 {
        return Ok(0);
    }
    return Ok(protobuf::rt::int32_size(number, value as i32));
}

fn compute_enum_size(field: &FieldDescriptorProto, json_value: &Value) -> Result<u64, Status> {
    let mut size = 0;
    if is_array(field) {
        if !json_value.is_array() {
            return Err(Status::error(format!(
                "{} 类型错误, 应为数组！",
                field.name.as_ref().unwrap()
            )));
        }
        for ele in json_value.as_array().unwrap() {
            size += compute_one_enum_size(field, ele)?;
        }
        Ok(size)
    } else {
        compute_one_enum_size(field, json_value)
    }
}

// enum
fn write_one_enum(
    field: &FieldDescriptorProto,
    json_value: &Value,
    output_stream: &mut CodedOutputStream,
) -> Result<(), Status> {
    let number = field.number.unwrap() as u32;
    let value = json_value.as_i64().unwrap();
    if value == 0 {
        return Ok(());
    }
    let result = output_stream.write_enum(number, value as i32);
    if result.is_err() {
        return Err(Status::error(format!(
            "{} 序列化失败！",
            field.name.as_ref().unwrap()
        )));
    }
    Ok(())
}

//
fn write_enum(
    field: &FieldDescriptorProto,
    json_value: &Value,
    output_stream: &mut CodedOutputStream,
) -> Result<(), Status> {
    if is_array(field) {
        for ele in json_value.as_array().unwrap() {
            write_one_enum(field, ele, output_stream)?;
        }
        Ok(())
    } else {
        write_one_enum(field, json_value, output_stream)
    }
}

fn compute_one_uint32_size(
    field: &FieldDescriptorProto,
    json_value: &Value,
) -> Result<u64, Status> {
    let number = field.number.unwrap() as u32;
    if !json_value.is_u64() {
        return Err(Status::error(format!(
            "{} 类型错误！",
            field.name.as_ref().unwrap()
        )));
    }
    let value = json_value.as_u64().unwrap();
    if value == 0 {
        return Ok(0);
    }
    return Ok(protobuf::rt::uint32_size(number, value as u32));
}

fn compute_uint32_size(field: &FieldDescriptorProto, json_value: &Value) -> Result<u64, Status> {
    let mut size = 0;
    if is_array(field) {
        if !json_value.is_array() {
            return Err(Status::error(format!(
                "{} 类型错误, 应为数组！",
                field.name.as_ref().unwrap()
            )));
        }
        for ele in json_value.as_array().unwrap() {
            size += compute_one_uint32_size(field, ele)?;
        }
        Ok(size)
    } else {
        compute_one_uint32_size(field, json_value)
    }
}

// uint32
fn write_one_uint32(
    field: &FieldDescriptorProto,
    json_value: &Value,
    output_stream: &mut CodedOutputStream,
) -> Result<(), Status> {
    let number = field.number.unwrap() as u32;
    let value = json_value.as_u64().unwrap();
    if value == 0 {
        return Ok(());
    }
    let result = output_stream.write_uint32(number, value as u32);
    if result.is_err() {
        return Err(Status::error(format!(
            "{} 序列化失败！",
            field.name.as_ref().unwrap()
        )));
    }
    Ok(())
}

//
fn write_uint32(
    field: &FieldDescriptorProto,
    json_value: &Value,
    output_stream: &mut CodedOutputStream,
) -> Result<(), Status> {
    if is_array(field) {
        for ele in json_value.as_array().unwrap() {
            write_one_uint32(field, ele, output_stream)?;
        }
        Ok(())
    } else {
        write_one_uint32(field, json_value, output_stream)
    }
}
//

fn compute_one_fixed32_size(
    field: &FieldDescriptorProto,
    json_value: &Value,
) -> Result<u64, Status> {
    if !json_value.is_u64() {
        return Err(Status::error(format!(
            "{} 类型错误！",
            field.name.as_ref().unwrap()
        )));
    }
    let value = json_value.as_u64().unwrap();
    if value == 0 {
        return Ok(0);
    }
    return Ok(1 + 4);
}

fn compute_fixed32_size(field: &FieldDescriptorProto, json_value: &Value) -> Result<u64, Status> {
    let mut size = 0;
    if is_array(field) {
        if !json_value.is_array() {
            return Err(Status::error(format!(
                "{} 类型错误, 应为数组！",
                field.name.as_ref().unwrap()
            )));
        }
        for ele in json_value.as_array().unwrap() {
            size += compute_one_fixed32_size(field, ele)?;
        }
        Ok(size)
    } else {
        compute_one_fixed32_size(field, json_value)
    }
}

//
// fixed32
fn write_one_fixed32(
    field: &FieldDescriptorProto,
    json_value: &Value,
    output_stream: &mut CodedOutputStream,
) -> Result<(), Status> {
    let number = field.number.unwrap() as u32;
    let value = json_value.as_u64().unwrap();
    if value == 0 {
        return Ok(());
    }
    let result = output_stream.write_fixed32(number, value as u32);
    if result.is_err() {
        return Err(Status::error(format!(
            "{} 序列化失败！",
            field.name.as_ref().unwrap()
        )));
    }
    Ok(())
}
//

//
fn write_fixed32(
    field: &FieldDescriptorProto,
    json_value: &Value,
    output_stream: &mut CodedOutputStream,
) -> Result<(), Status> {
    if is_array(field) {
        for ele in json_value.as_array().unwrap() {
            write_one_fixed32(field, ele, output_stream)?;
        }
        Ok(())
    } else {
        write_one_fixed32(field, json_value, output_stream)
    }
}

// fixed64
fn write_one_fixed64(
    field: &FieldDescriptorProto,
    json_value: &Value,
    output_stream: &mut CodedOutputStream,
) -> Result<(), Status> {
    let number = field.number.unwrap() as u32;

    let value = json_value.as_u64().unwrap();
    if value == 0 {
        return Ok(());
    }
    let result = output_stream.write_fixed64(number, value);
    if result.is_err() {
        return Err(Status::error(format!(
            "{} 序列化失败！",
            field.name.as_ref().unwrap()
        )));
    }
    Ok(())
}

fn compute_one_fixed64_size(
    field: &FieldDescriptorProto,
    json_value: &Value,
) -> Result<u64, Status> {
    if !json_value.is_u64() {
        return Err(Status::error(format!(
            "{} 类型错误！",
            field.name.as_ref().unwrap()
        )));
    }
    let value = json_value.as_u64().unwrap();
    if value == 0 {
        return Ok(0);
    }
    return Ok(1 + 8);
}

fn compute_fixed64_size(field: &FieldDescriptorProto, json_value: &Value) -> Result<u64, Status> {
    let mut size = 0;
    if is_array(field) {
        if !json_value.is_array() {
            return Err(Status::error(format!(
                "{} 类型错误, 应为数组！",
                field.name.as_ref().unwrap()
            )));
        }
        for ele in json_value.as_array().unwrap() {
            size += compute_one_fixed64_size(field, ele)?;
        }
        Ok(size)
    } else {
        compute_one_fixed64_size(field, json_value)
    }
}

//
fn write_fixed64(
    field: &FieldDescriptorProto,
    json_value: &Value,
    output_stream: &mut CodedOutputStream,
) -> Result<(), Status> {
    if is_array(field) {
        for ele in json_value.as_array().unwrap() {
            write_one_fixed64(field, ele, output_stream)?;
        }
        Ok(())
    } else {
        write_one_fixed64(field, json_value, output_stream)
    }
}

//
fn compute_one_int32_size(field: &FieldDescriptorProto, json_value: &Value) -> Result<u64, Status> {
    let number = field.number.unwrap() as u32;
    if !json_value.is_i64() {
        return Err(Status::error(format!(
            "{} 类型错误！",
            field.name.as_ref().unwrap()
        )));
    }
    let value = json_value.as_i64().unwrap();
    if value == 0 {
        return Ok(0);
    }
    return Ok(protobuf::rt::int32_size(number, value as i32));
}

fn compute_int32_size(field: &FieldDescriptorProto, json_value: &Value) -> Result<u64, Status> {
    let mut size = 0;
    if is_array(field) {
        if !json_value.is_array() {
            return Err(Status::error(format!(
                "{} 类型错误, 应为数组！",
                field.name.as_ref().unwrap()
            )));
        }
        for ele in json_value.as_array().unwrap() {
            size += compute_one_int32_size(field, ele)?;
        }
        Ok(size)
    } else {
        compute_one_int32_size(field, json_value)
    }
}

// i32
fn write_one_int32(
    field: &FieldDescriptorProto,
    json_value: &Value,
    output_stream: &mut CodedOutputStream,
) -> Result<(), Status> {
    let number = field.number.unwrap() as u32;
    let value = json_value.as_i64().unwrap();
    if value == 0 {
        return Ok(());
    }
    let result = output_stream.write_int32(number, value as i32);
    if result.is_err() {
        return Err(Status::error(format!(
            "{} 序列化失败！",
            field.name.as_ref().unwrap()
        )));
    }
    Ok(())
}

//
fn write_int32(
    field: &FieldDescriptorProto,
    json_value: &Value,
    output_stream: &mut CodedOutputStream,
) -> Result<(), Status> {
    if is_array(field) {
        for ele in json_value.as_array().unwrap() {
            write_one_int32(field, ele, output_stream)?;
        }
        Ok(())
    } else {
        write_one_int32(field, json_value, output_stream)
    }
}

fn compute_one_uint64_size(
    field: &FieldDescriptorProto,
    json_value: &Value,
) -> Result<u64, Status> {
    let number = field.number.unwrap() as u32;
    if !json_value.is_u64() {
        return Err(Status::error(format!(
            "{} 类型错误！",
            field.name.as_ref().unwrap()
        )));
    }
    let value = json_value.as_u64().unwrap();
    if value == 0 {
        return Ok(0);
    }
    return Ok(protobuf::rt::uint64_size(number, value));
}

fn compute_uint64_size(field: &FieldDescriptorProto, json_value: &Value) -> Result<u64, Status> {
    let mut size = 0;
    if is_array(field) {
        if !json_value.is_array() {
            return Err(Status::error(format!(
                "{} 类型错误, 应为数组！",
                field.name.as_ref().unwrap()
            )));
        }
        for ele in json_value.as_array().unwrap() {
            size += compute_one_uint64_size(field, ele)?;
        }
        Ok(size)
    } else {
        compute_one_uint64_size(field, json_value)
    }
}

// u64
fn write_one_uint64(
    field: &FieldDescriptorProto,
    json_value: &Value,
    output_stream: &mut CodedOutputStream,
) -> Result<(), Status> {
    let number = field.number.unwrap() as u32;
    let value = json_value.as_u64().unwrap();
    if value == 0 {
        return Ok(());
    }
    let result = output_stream.write_uint64(number, value);
    if result.is_err() {
        return Err(Status::error(format!(
            "{} 序列化失败！",
            field.name.as_ref().unwrap()
        )));
    }
    Ok(())
}

//
fn write_uint64(
    field: &FieldDescriptorProto,
    json_value: &Value,
    output_stream: &mut CodedOutputStream,
) -> Result<(), Status> {
    if is_array(field) {
        for ele in json_value.as_array().unwrap() {
            write_one_uint64(field, ele, output_stream)?;
        }
        Ok(())
    } else {
        write_one_uint64(field, json_value, output_stream)
    }
}
//

fn compute_one_int64_size(field: &FieldDescriptorProto, json_value: &Value) -> Result<u64, Status> {
    let number = field.number.unwrap() as u32;
    if !json_value.is_i64() {
        return Err(Status::error(format!(
            "{} 类型错误！",
            field.name.as_ref().unwrap()
        )));
    }
    let value = json_value.as_i64().unwrap();
    if value == 0 {
        return Ok(0);
    }
    return Ok(protobuf::rt::int64_size(number, value));
}

fn compute_int64_size(field: &FieldDescriptorProto, json_value: &Value) -> Result<u64, Status> {
    let mut size = 0;

    if is_array(field) {
        if !json_value.is_array() {
            return Err(Status::error(format!(
                "{} 类型错误, 应为数组！",
                field.name.as_ref().unwrap()
            )));
        }
        for ele in json_value.as_array().unwrap() {
            size += compute_one_int64_size(field, ele)?;
        }
        Ok(size)
    } else {
        compute_one_int64_size(field, json_value)
    }
}

//
fn write_one_int64(
    field: &FieldDescriptorProto,
    json_value: &Value,
    output_stream: &mut CodedOutputStream,
) -> Result<(), Status> {
    let number = field.number.unwrap() as u32;
    let value = json_value.as_i64().unwrap();
    if value == 0 {
        return Ok(());
    }
    let result = output_stream.write_int64(number, value);
    if result.is_err() {
        return Err(Status::error(format!(
            "{} 序列化失败！",
            field.name.as_ref().unwrap()
        )));
    }
    Ok(())
}

//
fn write_int64(
    field: &FieldDescriptorProto,
    json_value: &Value,
    output_stream: &mut CodedOutputStream,
) -> Result<(), Status> {
    if is_array(field) {
        for ele in json_value.as_array().unwrap() {
            write_one_int64(field, ele, output_stream)?;
        }
        Ok(())
    } else {
        write_one_int64(field, json_value, output_stream)
    }
}

// 写入字符串

fn compute_one_string_size(
    field: &FieldDescriptorProto,
    json_value: &Value,
) -> Result<u64, Status> {
    let number = field.number.unwrap() as u32;
    if !json_value.is_string() {
        return Err(Status::error(format!(
            "{} 类型错误！",
            field.name.as_ref().unwrap()
        )));
    }
    let value = json_value.as_str().unwrap();
    if value.is_empty() {
        return Ok(0);
    }
    Ok(protobuf::rt::string_size(number, value))
}

//
fn compute_string_size(field: &FieldDescriptorProto, json_value: &Value) -> Result<u64, Status> {
    let mut size = 0;
    if is_array(field) {
        if !json_value.is_array() {
            return Err(Status::error(format!(
                "{} 类型错误, 应为数组！",
                field.name.as_ref().unwrap()
            )));
        }
        for ele in json_value.as_array().unwrap() {
            size += compute_one_string_size(field, ele)?;
        }
        Ok(size)
    } else {
        compute_one_string_size(field, json_value)
    }
}

fn write_one_string(
    field: &FieldDescriptorProto,
    json_value: &Value,
    output_stream: &mut CodedOutputStream,
) -> Result<(), Status> {
    let number = field.number.unwrap() as u32;
    let value = json_value.as_str().unwrap();
    if value.is_empty() {
        return Ok(());
    }
    let result = output_stream.write_string(number, value);
    if result.is_err() {
        return Err(Status::error(format!(
            "{} 序列化失败！",
            field.name.as_ref().unwrap()
        )));
    }
    Ok(())
}

//
fn write_string(
    field: &FieldDescriptorProto,
    json_value: &Value,
    output_stream: &mut CodedOutputStream,
) -> Result<(), Status> {
    if is_array(field) {
        for ele in json_value.as_array().unwrap() {
            write_one_string(field, ele, output_stream)?;
        }
        Ok(())
    } else {
        write_one_string(field, json_value, output_stream)
    }
}

fn compute_object_size(
    field: &FieldDescriptorProto,
    json_value: &Value,
    service_api_descriptor: &ServiceApiDescriptor,
) -> Result<u64, Status> {
    if field.type_name.is_none() {
        return Err(Status::error(format!(
            "{} 类型错误, 应为数组！",
            field.name.as_ref().unwrap()
        )));
    }

    let type_name = field.type_name.as_ref().unwrap();
    let mut size = 0;
    if is_array(field) {
        if !json_value.is_array() {
            return Err(Status::error(format!(
                "{} 类型错误, 应为数组！",
                field.name.as_ref().unwrap()
            )));
        }
        for ele in json_value.as_array().unwrap() {
            let len = compute_size(ele, type_name, service_api_descriptor)?;
            size += 1 + protobuf::rt::compute_raw_varint64_size(len) + len;
        }
    } else {
        let len = compute_size(json_value, type_name, service_api_descriptor)?;

        size = 1 + protobuf::rt::compute_raw_varint64_size(len) + len;
    }
    Ok(size)
}

fn write_object(
    field: &FieldDescriptorProto,
    json_value: &Value,
    service_api_descriptor: &ServiceApiDescriptor,
    output_stream: &mut CodedOutputStream,
) -> Result<(), Status> {
    let type_name = field.type_name.as_ref().unwrap();

    if is_array(field) {
        let number = field.number.unwrap() as u32;
        for ele in json_value.as_array().unwrap() {
            output_stream
                .write_tag(number, protobuf::rt::WireType::LengthDelimited)
                .unwrap();
            let len = compute_size(ele, type_name, service_api_descriptor)?;
            output_stream.write_raw_varint32(len as u32).unwrap();

            json_to_proto_with_buffer(ele, type_name, service_api_descriptor, output_stream)?;
        }
        Ok(())
    } else {
        let number = field.number.unwrap() as u32;
        output_stream
            .write_tag(number, protobuf::rt::WireType::LengthDelimited)
            .unwrap();
        let len = compute_size(json_value, type_name, service_api_descriptor)?;
        output_stream.write_raw_varint32(len as u32).unwrap();

        json_to_proto_with_buffer(json_value, type_name, service_api_descriptor, output_stream)
    }
}

fn compute_json_key_size(field_type: Type, key: &str) -> Result<u64, Status> {
    match field_type {
        Type::TYPE_DOUBLE => Ok(2 + 8),
        Type::TYPE_FLOAT => Ok(2 + 4),
        Type::TYPE_INT64 => {
            let value: Result<i64, _> = key.parse();
            Ok(::protobuf::rt::int64_size(1, value.unwrap()))
        }
        Type::TYPE_UINT64 => {
            let value: Result<u64, _> = key.parse();
            Ok(::protobuf::rt::uint64_size(1, value.unwrap()))
        }
        Type::TYPE_INT32 => {
            let value: Result<i32, _> = key.parse();
            Ok(::protobuf::rt::int32_size(1, value.unwrap()))
        }
        Type::TYPE_FIXED64 => Ok(1 + 8),
        Type::TYPE_FIXED32 => Ok(1 + 4),
        Type::TYPE_BOOL => Ok(2 + 1),
        Type::TYPE_STRING => Ok(::protobuf::rt::string_size(1, key)),
        Type::TYPE_UINT32 => {
            let value: Result<u32, _> = key.parse();
            Ok(::protobuf::rt::uint32_size(1, value.unwrap()))
        }
        Type::TYPE_SFIXED32 => Ok(2 + 8),
        Type::TYPE_SFIXED64 => Ok(2 + 4),
        Type::TYPE_SINT32 => {
            let value: Result<i32, _> = key.parse();
            Ok(::protobuf::rt::sint32_size(1, value.unwrap()))
        }
        Type::TYPE_SINT64 => {
            let value: Result<i64, _> = key.parse();
            Ok(::protobuf::rt::sint64_size(1, value.unwrap()))
        }
        _ => {
            return Err(Status::error(format!("无消息 描述信息！")));
        }
    }
}

fn compute_size_inner(
    field_type: Type,
    field: &FieldDescriptorProto,
    service_api_descriptor: &ServiceApiDescriptor,
    json_value: &Value,
) -> Result<u64, Status> {
    match field_type {
        // i64
        Type::TYPE_INT64 => compute_int64_size(field, json_value),
        // ui64
        Type::TYPE_UINT64 => compute_uint64_size(field, json_value),
        // i32
        Type::TYPE_INT32 => compute_int32_size(field, json_value),
        // fixed64
        Type::TYPE_FIXED64 => compute_fixed64_size(field, json_value),
        // fixed32
        Type::TYPE_FIXED32 => compute_fixed32_size(field, json_value),
        // u32
        Type::TYPE_UINT32 => compute_uint32_size(field, json_value),
        // enum
        Type::TYPE_ENUM => compute_enum_size(field, json_value),
        // sfixed32
        Type::TYPE_SFIXED32 => compute_sfixed32_size(field, json_value),
        // sfixed64
        Type::TYPE_SFIXED64 => compute_sfixed64_size(field, json_value),
        // sint32
        Type::TYPE_SINT32 => compute_sint32_size(field, json_value),
        // sint64
        Type::TYPE_SINT64 => compute_sint64_size(field, json_value),
        // double
        Type::TYPE_DOUBLE => compute_double_size(field, json_value),
        //
        Type::TYPE_FLOAT => compute_float_size(field, json_value),
        //
        Type::TYPE_STRING => compute_string_size(field, json_value),
        // 对象
        Type::TYPE_MESSAGE => compute_object_size(field, json_value, service_api_descriptor),
        // 对象
        Type::TYPE_BOOL => compute_bool_size(field, json_value),
        //
        _ => {
            return Err(Status::error(format!("无消息 描述信息！")));
        }
    }
}

//

pub fn compute_size(
    json_obj: &Value,
    msg_name: &str,
    service_api_descriptor: &ServiceApiDescriptor,
) -> Result<u64, Status> {
    let mut buffer_size = 0;
    let message_descriptor_holder = service_api_descriptor
        .message_descriptor_holder
        .get(msg_name);

    if message_descriptor_holder.is_none() {
        return Err(Status::error(format!("无消息：{} 描述信息！", msg_name)));
    }
    let msg_descriptor = &message_descriptor_holder.unwrap().descriptor_proto;

    for field in &msg_descriptor.field {
        let field_name = field.name.as_ref().unwrap();
        let json_value = json_obj.get(field_name);
        if json_value.is_none() {
            continue;
        }

        let json_value = json_value.unwrap();
        let field_type = field.type_.unwrap().unwrap();

        if field_type == Type::TYPE_MESSAGE && is_map(field, service_api_descriptor) {
            if !json_value.is_object() {
                return Err(Status::error(format!("{} 类型错误，应为 obj", msg_name)));
            }

            let map_type_name = field.type_name.as_ref().unwrap();

            let map_msg_descriptor_holder = service_api_descriptor
                .message_descriptor_holder
                .get(map_type_name);

            let message_descriptor = &map_msg_descriptor_holder.unwrap().descriptor_proto;

            let key_field = message_descriptor.field.get(0).unwrap();

            let value_field = message_descriptor.field.get(1).unwrap();

            let key_field_type = key_field.type_.unwrap().unwrap();

            let value_field_type = value_field.type_.unwrap().unwrap();
            //

            let obj_value = json_value.as_object().unwrap();

            for (key, value) in obj_value {
                let mut entry_size = 0;
                entry_size += compute_json_key_size(key_field_type, key)?;

                entry_size += compute_size_inner(
                    value_field_type,
                    value_field,
                    service_api_descriptor,
                    value,
                )?;
                buffer_size +=
                    2 + ::protobuf::rt::compute_raw_varint64_size(entry_size) + entry_size;
            }
        } else {
            buffer_size +=
                compute_size_inner(field_type, field, service_api_descriptor, json_value)?;
        }
    }

    Ok(buffer_size)
}

fn write_json_key(
    field_type: Type,
    key: &str,
    output_stream: &mut CodedOutputStream,
) -> Result<(), Status> {
    match field_type {
        Type::TYPE_DOUBLE => {
            let value: Result<f64, _> = key.parse();
            output_stream.write_double(1, value.unwrap()).unwrap();
        }
        Type::TYPE_FLOAT => {
            let value: Result<f32, _> = key.parse();
            output_stream.write_float(1, value.unwrap()).unwrap();
        }
        Type::TYPE_INT64 => {
            let value: Result<i64, _> = key.parse();
            output_stream.write_int64(1, value.unwrap()).unwrap();
        }
        Type::TYPE_UINT64 => {
            let value: Result<u64, _> = key.parse();
            output_stream.write_uint64(1, value.unwrap()).unwrap();
        }
        Type::TYPE_INT32 => {
            let value: Result<i32, _> = key.parse();
            output_stream.write_int32(1, value.unwrap()).unwrap();
        }
        Type::TYPE_FIXED64 => {
            let value: Result<u64, _> = key.parse();
            output_stream.write_fixed64(1, value.unwrap()).unwrap();
        }
        Type::TYPE_FIXED32 => {
            let value: Result<u32, _> = key.parse();
            output_stream.write_fixed32(1, value.unwrap()).unwrap();
        }
        Type::TYPE_BOOL => {
            let value: Result<bool, _> = key.parse();
            output_stream.write_bool(1, value.unwrap()).unwrap();
        }
        Type::TYPE_STRING => {
            output_stream.write_string(1, key).unwrap();
        }
        Type::TYPE_UINT32 => {
            let value: Result<u32, _> = key.parse();
            output_stream.write_uint32(1, value.unwrap()).unwrap();
        }
        Type::TYPE_SFIXED32 => {
            let value: Result<i32, _> = key.parse();
            output_stream.write_sfixed32(1, value.unwrap()).unwrap();
        }
        Type::TYPE_SFIXED64 => {
            let value: Result<i64, _> = key.parse();
            output_stream.write_sfixed64(1, value.unwrap()).unwrap();
        }
        Type::TYPE_SINT32 => {
            let value: Result<i32, _> = key.parse();
            output_stream.write_sint32(1, value.unwrap()).unwrap();
        }
        Type::TYPE_SINT64 => {
            let value: Result<i64, _> = key.parse();
            output_stream.write_sint64(1, value.unwrap()).unwrap();
        }
        _ => {
            return Err(Status::error(format!("无消息 描述信息！")));
        }
    };
    Ok(())
}

fn json_to_proto_with_buffer_inner(
    field_type: Type,
    field: &FieldDescriptorProto,
    json_value: &Value,
    service_api_descriptor: &ServiceApiDescriptor,
    output_stream: &mut CodedOutputStream,
) -> Result<(), Status> {
    match field_type {
        // i64
        Type::TYPE_INT64 => write_int64(field, json_value, output_stream),
        // ui64
        Type::TYPE_UINT64 => write_uint64(field, json_value, output_stream),
        // i32
        Type::TYPE_INT32 => write_int32(field, json_value, output_stream),
        // fixed64
        Type::TYPE_FIXED64 => write_fixed64(field, json_value, output_stream),
        // fixed32
        Type::TYPE_FIXED32 => write_fixed32(field, json_value, output_stream),
        // u32
        Type::TYPE_UINT32 => write_uint32(field, json_value, output_stream),
        // enum
        Type::TYPE_ENUM => write_enum(field, json_value, output_stream),
        // sfixed32
        Type::TYPE_SFIXED32 => write_sfixed32(field, json_value, output_stream),
        // sfixed64
        Type::TYPE_SFIXED64 => write_sfixed64(field, json_value, output_stream),
        // sint32
        Type::TYPE_SINT32 => write_sint32(field, json_value, output_stream),
        // sint64
        Type::TYPE_SINT64 => write_sint64(field, json_value, output_stream),
        // double
        Type::TYPE_DOUBLE => write_double(field, json_value, output_stream),
        //
        Type::TYPE_FLOAT => write_float(field, json_value, output_stream),
        //
        Type::TYPE_STRING => write_string(field, json_value, output_stream),
        // 对象
        Type::TYPE_MESSAGE => {
            write_object(field, json_value, service_api_descriptor, output_stream)
        }
        // 对象
        Type::TYPE_BOOL => write_bool(field, json_value, output_stream),
        //
        _ => Err(Status::error("类型错误！".into())),
    }
}

pub fn json_to_proto_with_buffer(
    json_obj: &Value,
    msg_name: &str,
    service_api_descriptor: &ServiceApiDescriptor,
    output_stream: &mut CodedOutputStream,
) -> Result<(), Status> {
    let msg_descriptor_holder = service_api_descriptor
        .message_descriptor_holder
        .get(msg_name);

    let msg_descriptor = &msg_descriptor_holder.unwrap().descriptor_proto;

    for field in &msg_descriptor.field {
        let field_name = field.name.as_ref().unwrap();

        let json_value = json_obj.get(field_name);

        if json_value.is_none() {
            continue;
        }
        let json_value = json_value.unwrap();
        let field_type = field.type_.unwrap().unwrap();

        if field_type == Type::TYPE_MESSAGE && is_map(field, service_api_descriptor) {
            let map_type_name = field.type_name.as_ref().unwrap();

            let map_msg_descriptor_holder = service_api_descriptor
                .message_descriptor_holder
                .get(map_type_name);

            let message_descriptor = &map_msg_descriptor_holder.unwrap().descriptor_proto;

            let key_field = message_descriptor.field.get(0).unwrap();

            let value_field = message_descriptor.field.get(1).unwrap();

            let key_field_type = key_field.type_.unwrap().unwrap();

            let value_field_type = value_field.type_.unwrap().unwrap();
            //
            let obj_value = json_value.as_object().unwrap();

            let number = field.number() as u32;

            let wire_type = get_wire_type(field);

            let tag = make_tag(number, wire_type);

            for (key, value) in obj_value {
                let mut entry_size = 0;
                entry_size += compute_json_key_size(key_field_type, key)?;
                entry_size += compute_size_inner(
                    value_field_type,
                    value_field,
                    service_api_descriptor,
                    value,
                )?;
                output_stream.write_raw_varint32(tag).unwrap();
                output_stream.write_raw_varint32(entry_size as u32).unwrap();
                // 写入key
                write_json_key(key_field_type, key, output_stream)?;

                // 写入 value
                json_to_proto_with_buffer_inner(
                    value_field_type,
                    value_field,
                    value,
                    service_api_descriptor,
                    output_stream,
                )?
            }
        } else {
            json_to_proto_with_buffer_inner(
                field_type,
                field,
                json_value,
                service_api_descriptor,
                output_stream,
            )?
        }
    }
    Ok(())
}

pub fn json_to_proto(
    json: &str,
    msg_name: &str,
    service_api_descriptor: &ServiceApiDescriptor,
) -> Result<Vec<u8>, Status> {
    let json_obj: Result<Value, _> = serde_json::from_str(json);

    if json_obj.is_err() {
        return Err(Status::error(json_obj.err().unwrap().to_string()));
    }
    let json_obj = json_obj.as_ref().unwrap();

    json_value_to_proto(json_obj, msg_name, service_api_descriptor)
}

pub fn json_value_to_proto(
    json_value: &Value,
    msg_name: &str,
    service_api_descriptor: &ServiceApiDescriptor,
) -> Result<Vec<u8>, Status> {
    let buffer_size = compute_size(json_value, msg_name, service_api_descriptor)?;
    let mut buffer = Vec::with_capacity(buffer_size as usize);

    let mut output_stream = CodedOutputStream::vec(&mut buffer);

    json_to_proto_with_buffer(
        json_value,
        msg_name,
        service_api_descriptor,
        &mut output_stream,
    )?;

    let flush_result = output_stream.flush();

    if flush_result.is_err() {
        return Err(Status::error(flush_result.err().unwrap().to_string()));
    }
    drop(output_stream);

    Ok(buffer)
}