

use std::{  time  };
use crate::prelude::*;



#[gen_特征_derive(MOD特征_tool_cipher)]
impl 信令路由{
    async fn exec文本信令_tool_cipher(&self,函数名:&str, mut 参数数组:Vec<String>)-> anyhow_Result<(bool,Value,Vec<String>)>{
        let 信令路由ref = self;
        let 结果 = match 函数名{
            "AES加密文本"=>{    
                if 参数数组.len() < 1 {  return Err(anyhow_err!("aes加密文本, 缺少参数:: <文本>  <密钥>")); }  
                let 密钥 = if 参数数组.len()>=2{ Some(参数数组.remove(1)) }else{ None };
                json!(信令路由ref.密码_AES加密(参数数组.remove(0) ,密钥).await?)
            }
            "AES解密文本"=>{ 
                if 参数数组.len() < 1 {  return Err(anyhow_err!("aes解密文本, 缺少参数:: <文本>  <密钥>")); }   
                let 密钥 = if 参数数组.len()>=2{ Some(参数数组.remove(1)) }else{ None };
                json!(信令路由ref.密码_AES解密(参数数组.remove(0) ,密钥).await?)
            }
            _=>{ return Ok((false, json!(""), 参数数组)); }
        };
        Ok((true, 结果, Vec::new()))
    }

    fn 密码_AES加密(&self,文本:String,密钥: Option<String>)-> impl 信令任务<String>{
        core发布信令任务!(self, 信令表::密码_AES加密{ 文本, 密钥  },  信令表::密码_AES加密_回复 => 文本 )
    }
    fn 密码_AES解密(&self,文本:String,密钥: Option<String>)-> impl 信令任务<String>{
        core发布信令任务!(self, 信令表::密码_AES解密{ 文本, 密钥  },  信令表::密码_AES解密_回复 => 文本 )
    }

}


#[derive(Clone, Serialize, Deserialize)]//可选特征
enum 信令表{
    密码_AES加密{      文本:String, 密钥:Option<String>   },
    密码_AES加密_回复{  文本:String   },
    密码_AES解密{      文本:String, 密钥:Option<String>   },
    密码_AES解密_回复{  文本:String   },

}
impl信令特征!(信令表, 执行函数);

async fn 执行函数(信令路由:信令路由,id:信令ID,单个信令:信令表)->anyhow_Result<信令表>{ 
    match 单个信令{
        信令表::密码_AES加密{ 文本 , 密钥 }=>{
            let 处理密码 = 密码::new(文本.clone(), 密钥, None); 
            let 结果 = 处理密码.AES_CBC加密() .map(|返回|{  信令表::密码_AES加密_回复{ 文本:返回  }  })
                            .map_err(|err|{  anyhow_err!("密码_aes加密错误: {文本} -> {err}")   }); 
            anyhow_Ok信令!(结果?)
        }
        信令表::密码_AES解密{ 文本 , 密钥  }=>{
            let 处理密码 = 密码::new(文本.clone(), 密钥, None); 
            let 结果 = 处理密码.AES_CBC解密() .map(|返回|{  信令表::密码_AES解密_回复{ 文本:返回  }  })
                            .map_err(|err|{  anyhow_err!("密码_aes解密错误: {文本} -> {err}")   }); 
            anyhow_Ok信令!(结果?)
        }
        _ =>{ return Err(anyhow_err!("信令不存在")); }
    }
}








use data_encoding::HEXLOWER;
use aes::{self,Aes256, cipher::{BlockEncrypt, BlockDecrypt,KeyInit, } };  //特征
#[derive(Debug)]
pub struct 密码{
    文本:String,
    密钥:Vec<u8>,
    iv: Vec<u8>,
}
impl 密码 {
    pub fn new(文本:String,密钥:Option<String>,iv:Option<String>)->Self{
        let 截取或补充16位 = |字符串:Option<String>, 默认字符串:&str|->Vec<u8>{ 
            let 可用 = if let Some(可用) = 字符串 { 可用 }else{  let mut s = "默认lwleen__".to_string(); s.push_str(默认字符串); s  };     //16bit
            let mut padded = 可用.into_bytes();
                if padded.len() >= 16{   padded[..16].to_vec()   }
                else{
                    let num = 16 - padded.len();
                    padded.extend(vec![num as u8; num]);
                    padded
                }
        };
        Self{
            文本,
            密钥: 截取或补充16位(密钥, "key密钥"),
            iv:  截取或补充16位(iv,"iv"),
        }
    }
    
    pub fn AES_CBC加密(&self)->anyhow_Result<String>{
        let mut buffer = self.pkcs7_pad填充(self.文本.clone().as_bytes(), 16);
        let key = self.密钥.clone(); 
        let iv = self.iv.clone();      // 16字节的初始化向量
        
        let cipher = aes::Aes128::new_from_slice(key.as_slice()).map_err(|err|anyhow_err!("AES_CBC加密    aes::Aes128::new_from_slice 错误"))?;
        let mut prev_block = iv;
        
        for chunk in buffer.chunks_mut(16) { 
            for i in 0..16 { chunk[i] ^= prev_block[i]; }   // 异或操作 
            let mut block = aes::cipher::generic_array::GenericArray::clone_from_slice(chunk);   // 加密块
            cipher.encrypt_block(&mut block);
            chunk.copy_from_slice(&block); 
            prev_block.copy_from_slice(chunk);             //chunk 是加密后的  更新前一个块 
        }
        
        let 密文 = HEXLOWER.encode(&buffer);
        Ok(密文)
    }
    pub fn AES_CBC解密(&self)->anyhow_Result<String>{
        let mut buffer = HEXLOWER.decode(self.文本.as_bytes())?;
        let key = self.密钥.clone(); 
        let iv = self.iv.clone();      // 16字节的初始化向量
        
        let cipher = aes::Aes128::new_from_slice(key.as_slice()).map_err(|err|anyhow_err!("AES_CBC解密    aes::Aes128::new_from_slice 错误"))?;
        let mut prev_block = iv;
    
        for chunk in buffer.chunks_mut(16) { 
            let mut block = aes::cipher::generic_array::GenericArray::clone_from_slice(chunk);  // 解密块
            cipher.decrypt_block(&mut block); 
            for i in 0..16 {  block[i] ^= prev_block[i]; }   // 异或操作
            prev_block.copy_from_slice(chunk);                  //chunk 是加密后的  更新前一个块  
            chunk.copy_from_slice(&block); 
        }

        buffer = self.pkcs7_unpad删除填充(&buffer )?;
        let 明文 = String::from_utf8(buffer)?;
        Ok(明文)
    }
    

    fn pkcs7_pad填充(&self,data: &[u8],  block_size: usize) -> Vec<u8> {   //使得加密任意长度的字符串
        let pad_len = block_size - (data.len() % block_size);       //1 ~ 16个
        let mut padded = data.to_vec();
        padded.extend(vec![pad_len as u8; pad_len]);                 //填入最后一个   1 ~ 16个
        padded
    }
    fn pkcs7_unpad删除填充(&self,data: &[u8]) -> anyhow_Result<Vec<u8>> {
        let pad_len = data[data.len() - 1] as usize;
        if data.len() < pad_len {
            Err(anyhow_err!("AES_CBC解密错误: pkcs7_unpad删除填充 错误"))
        }else{
            Ok(data[..data.len() - pad_len].to_vec())
        }
    }
     
}


