usc 1.20230730.1349

use serde::Serialize;
use serde_json::*;


use crate::myerror::*;
use crate::{ mysome};
use itertools::Itertools;
use std::result::Result;



pub fn to_string<T>(value: &T) -> Result<String,serde_json::Error>
where
    T: ?Sized + Serialize,
{
    serde_json::to_string(value)
}



pub fn parse<'a, T>(json_str: &'a str) -> Result<T,Error>  where T : serde::Deserialize<'a>
{
    serde_json::from_str(json_str)
}

pub fn parse_mut<'a, T>(json_str: &'a str) -> Result<T,Error>  where T : serde::Deserialize<'a>
{
    serde_json::
    from_str(json_str)
}


pub fn myjson_get(val:&Value,path:&str,default_value:serde_json::Value)-> serde_json::Value {

    let arr=path.split(".").collect_vec();
    let length=arr.len();
    if length==1 {
        let key= * mysome!(arr.get(0),#,default_value);
        if key.len()==0{
            return default_value;
        }
        if !val.is_object(){
            return default_value;
        }
        let result= mysome!(mysome!(val.as_object(),#,default_value).get(key),#,default_value);
        return result.clone();
    }
    let mut point=val;
    for i in 0..length-1 {
        let key= * mysome!(arr.get(i),#,default_value);
        point=mysome!(mysome!(point.as_object(),#,default_value).get(key),#,default_value);
    }
    let key= * mysome!(arr.get(length-1),#,default_value);
    if key.len()==0{
        return default_value;
    }
    let a=mysome!(point.as_object(),#,default_value);
    let b=mysome!(a.get(key),#,default_value);
    return b.clone();
}

pub fn myjson_set_bool(val:& mut Value,path:&str,value:bool)->Result<(),MyError> {
    let arr=path.split(".").collect_vec();
    let length=arr.len();
    if length==1 {
        let key= * mysome!(arr.get(0));
        let  a=mysome!(val.as_object_mut());
        a.insert((key).parse().unwrap(), Value::Bool(value));
        return Ok(());
    }
    let mut point=val;


    for i in 0..length-1 {
        let key = *mysome!(arr.get(i));
        let  point_object=point.as_object_mut();
        let  parent = mysome!(point_object);
        let read_parent=&parent;
        let has_value = read_parent.get (key).is_some();
        if has_value {
            point=parent.get_mut(key).unwrap()
        } else{
            parent.insert((key).parse().unwrap(), json!({}));
             point=parent.get_mut(key).unwrap();
        }
    }
    let key= * mysome!(arr.get(length-1));
    if key.len()==0{
        return Err(MyError::new(format!("key错误:{}",path)));
    }
    let parent=mysome!(point.as_object_mut());
    parent.insert((&key).parse().unwrap(), Value::Bool(value));
    Ok(())
}

pub fn myjson_set_string(val:& mut Value,path:&str,value:&str)->Result<(),MyError> {
    let arr=path.split(".").collect_vec();
    let length=arr.len();
    if length==1 {
        let key= * mysome!(arr.get(0));
        let  a=mysome!(val.as_object_mut());
        a.insert((key).parse().unwrap(), Value::String(value.parse().unwrap()));
        return Ok(());
    }
    let mut point=val;


    for i in 0..length-1 {
        let key = *mysome!(arr.get(i));
        let  point_object=point.as_object_mut();
        let  parent = mysome!(point_object);
        let read_parent=&parent;
        let has_value = read_parent.get (key).is_some();
        if has_value {
            point=parent.get_mut(key).unwrap()
        } else{
            parent.insert((key).parse().unwrap(), json!({}));
             point=parent.get_mut(key).unwrap();
        }
    }
    let key= * mysome!(arr.get(length-1));
    if key.len()==0{
        return Err(MyError::new(format!("key错误:{}",path)));
    }
    let parent=mysome!(point.as_object_mut());
    parent.insert((&key).parse().unwrap(), Value::String(std::string::String::from(value)));
    Ok(())
}
pub fn myjson_set_f64(val:& mut Value,path:&str,value:f64)->Result<(),MyError> {
    let arr=path.split(".").collect_vec();
    let length=arr.len();
    if length==1 {
        let key= * mysome!(arr.get(0));
        let  a=mysome!(val.as_object_mut());
        a.insert((key).parse().unwrap(), Value::Number(mysome!(serde_json::Number::from_f64(value))));
        return Ok(());
    }
    let mut point=val;
    for i in 0..length-1 {
        let key = *mysome!(arr.get(i));
        let  point_object=point.as_object_mut();
        let  parent = mysome!(point_object);
        let read_parent=&parent;
        let has_value = read_parent.get (key).is_some();
        if has_value {
            point=parent.get_mut(key).unwrap()
        } else{
            parent.insert((key).parse().unwrap(), json!({}));
             point=parent.get_mut(key).unwrap();
        }
    }
    let key= * mysome!(arr.get(length-1));
    if key.len()==0{
        return Err(MyError::new(format!("key错误:{}",path)));
    }
    let parent=mysome!(point.as_object_mut());
    parent.insert((&key).parse().unwrap(), Value::Number (mysome!(serde_json::Number::from_f64(value))));
    Ok(())
}

pub fn myjson_append_to_vec(val:& mut Value,path:&str,value:& Value)->Result<(),MyError> {
    let arr=path.split(".").collect_vec();
    let length=arr.len();
    if length==1 {
        let key= * mysome!(arr.get(0));
        let  a=mysome!(val.as_object_mut());
        a.insert((key).parse().unwrap(), value.clone());
        return Ok(());
    }
    let mut point=val;
    for i in 0..length-1 {
        let key = *mysome!(arr.get(i));
        let  point_object=point.as_object_mut();
        let  parent = mysome!(point_object);
        let read_parent=&parent;
        let has_value = read_parent.get (key).is_some();
        if has_value {
            point=parent.get_mut(key).unwrap()
        } else{
            parent.insert((key).parse().unwrap(), json!({}));
             point=parent.get_mut(key).unwrap();
        }
    }
    let key= * mysome!(arr.get(length-1));
    if key.len()==0{
        return Err(MyError::new(format!("key错误:{}",path)));
    }
    let parent=mysome!(point.as_object_mut());
    let vec_value=parent.get_mut(&String::from(key));
    if vec_value.is_none(){
        let mut new_vec_value=vec![];
        new_vec_value.push(value.clone());
        parent.insert((&key).parse().unwrap(),serde_json::Value::Array(new_vec_value));
    }else{
        mysome!(vec_value.unwrap().as_array_mut()).push(value.clone());
    }
    Ok(())
}

pub fn myjson_set(val:& mut Value,path:&str,value:& Value)->Result<(),MyError> {
    let arr=path.split(".").collect_vec();
    let length=arr.len();
    if length==1 {
        let key= * mysome!(arr.get(0));
        let  a=mysome!(val.as_object_mut());
        a.insert((key).parse().unwrap(), value.clone());
        return Ok(());
    }
    let mut point=val;
    for i in 0..length-1 {
        let key = *mysome!(arr.get(i));
        let  point_object=point.as_object_mut();
        let  parent = mysome!(point_object);
        let read_parent=&parent;
        let has_value = read_parent.get (key).is_some();
        if has_value {
            point=parent.get_mut(key).unwrap()
        } else{
            parent.insert((key).parse().unwrap(), json!({}));
             point=parent.get_mut(key).unwrap();
        }
    }
    let key= * mysome!(arr.get(length-1));
    if key.len()==0{
        return Err(MyError::new(format!("key错误:{}",path)));
    }
    let parent=mysome!(point.as_object_mut());
    parent.insert((&key).parse().unwrap(), value.clone());
    Ok(())
}
pub fn myjson_set_i64(val:& mut Value,path:&str,value:i64)->Result<(),MyError> {
    let arr=path.split(".").collect_vec();
    let length=arr.len();
    if length==1 {
        let key= * mysome!(arr.get(0));
        let  a=mysome!(val.as_object_mut());
        a.insert((key).parse().unwrap(), Value::Number(serde_json::Number::from(value)));
        return Ok(());
    }
    let mut point=val;
    for i in 0..length-1 {
        let key = *mysome!(arr.get(i));
        let  point_object=point.as_object_mut();
        let  parent = mysome!(point_object);
        let read_parent=&parent;
        let has_value = read_parent.get (key).is_some();
        if has_value {
            point=parent.get_mut(key).unwrap()
        } else{
            parent.insert((key).parse().unwrap(), json!({}));
             point=parent.get_mut(key).unwrap();
        }
    }
    let key= * mysome!(arr.get(length-1));
    if key.len()==0{
        return Err(MyError::new(format!("key错误:{}",path)));
    }
    let parent=mysome!(point.as_object_mut());
    parent.insert((&key).parse().unwrap(), Value::Number (serde_json::Number::from(value)));
    Ok(())
}

pub fn myjson_get_bool(val:&Value,path:&str,default_value:bool)->bool {

    let arr=path.split(".").collect_vec();
    let length=arr.len();
    if length==1 {
        let key= * mysome!(arr.get(0),#,default_value);
        if key.len()==0{
            return default_value;
        }
        if !val.is_object(){
            return default_value;
        }
        let result= mysome!(mysome!(mysome!(val.as_object(),#,default_value).get(key),#,default_value).as_bool(),#,default_value);
        return result;
    }
    let mut point=val;
    for i in 0..length-1 {
        let key= * mysome!(arr.get(i),#,default_value);
        point=mysome!(mysome!(point.as_object(),#,default_value).get(key),#,default_value);
    }
    let key= * mysome!(arr.get(length-1),#,default_value);
    if key.len()==0{
        return default_value;
    }
    let a=mysome!(point.as_object(),#,default_value);
    let b=mysome!(a.get(key),#,default_value);
    let c=mysome!(b.as_bool(),#,default_value);
    let result= c;
    return result;
}

pub fn myjson_get_f64(val:&Value,path:&str,default_value:f64)->f64 {

    let arr=path.split(".").collect_vec();
    let length=arr.len();
    if length==1 {
        let key= * mysome!(arr.get(0),#,default_value);
        if key.len()==0{
            return default_value;
        }
        if !val.is_object(){
            return default_value;
        }
        let result= mysome!(mysome!(mysome!(val.as_object(),#,default_value).get(key),#,default_value).as_f64(),#,default_value);
        return result;
    }
    let mut point=val;
    for i in 0..length-1 {
        let key= * mysome!(arr.get(i),#,default_value);
        point=mysome!(mysome!(point.as_object(),#,default_value).get(key),#,default_value);
    }
    let key= * mysome!(arr.get(length-1),#,default_value);
    if key.len()==0{
        return default_value;
    }
    let a=mysome!(point.as_object(),#,default_value);
    let b=mysome!(a.get(key),#,default_value);
    let c=mysome!(b.as_f64(),#,default_value);
    let result= c;
    return result;
}
pub fn myjson_get_i64(val:&Value,path:&str,default_value:i64)->i64 {

    let arr=path.split(".").collect_vec();
    let length=arr.len();
    if length==1 {
        let key= * mysome!(arr.get(0),#,default_value);
        if key.len()==0{
            return default_value;
        }
        if !val.is_object(){
            return default_value;
        }
        let result= mysome!(mysome!(mysome!(val.as_object(),#,default_value).get(key),#,default_value).as_i64(),#,default_value);
        return result;
    }
    let mut point=val;
    for i in 0..length-1 {
        let key= * mysome!(arr.get(i),#,default_value);
        point=mysome!(mysome!(point.as_object(),#,default_value).get(key),#,default_value);
    }
    let key= * mysome!(arr.get(length-1),#,default_value);
    if key.len()==0{
        return default_value;
    }
    let a=mysome!(point.as_object(),#,default_value);
    let b=mysome!(a.get(key),#,default_value);
    let c=mysome!(b.as_i64(),#,default_value);
    let result= c;
    return result;
}

pub fn myjson_get_string(val:&Value,path:&str,default_value_str:&str)->  std::string::String {
    let default_value=default_value_str.to_owned();
    let arr=path.split(".").collect_vec();
    let length=arr.len();
    if length==1 {
        let key= * mysome!(arr.get(0),#,default_value);
        if key.len()==0{
            return default_value;
        }
        if !val.is_object(){
            return default_value;
        }
        let result= mysome!(mysome!(mysome!(val.as_object(),#,default_value).get(key),#,default_value).as_str(),#,default_value);
        return result.to_owned();
    }
    let mut point=val;
    for i in 0..length-1 {
        let key= * mysome!(arr.get(i),#,default_value);
        point=mysome!(mysome!(point.as_object(),#,default_value).get(key),#,default_value);
    }
    let key= * mysome!(arr.get(length-1),#,default_value);
    if key.len()==0{
        return default_value;
    }
    let a=mysome!(point.as_object(),#,default_value);
    let b=mysome!(a.get(key),#,default_value);
    let c=mysome!(b.as_str(),#,default_value);
    let result= c;
    return result.to_owned();
}