use crate::bytes_helper::u16_from_le_bytes;
use crate::tcp::Tdx;
#[derive(Debug, Clone, serde::Serialize)]
pub struct BlockRecord {
pub blockname: String,
pub block_type: u16,
pub code: String,
}
#[derive(Debug, Clone)]
pub struct BlockInfoMeta {
pub send: Box<[u8]>,
pub response: Vec<u8>,
pub size: u32,
}
impl BlockInfoMeta {
pub fn new(block_file: &str) -> Self {
let mut send = [0u8; Self::LEN];
send[0..12].copy_from_slice(Self::SEND);
let name = block_file.as_bytes();
let n = name.len().min(40);
send[12..12 + n].copy_from_slice(&name[..n]);
Self {
send: send.into(),
response: Vec::new(),
size: 0,
}
}
}
impl Tdx for BlockInfoMeta {
type Item = u32;
const SEND: &'static [u8] = &[
0x0c, 0x39, 0x18, 0x69, 0x00, 0x01, 0x2a, 0x00, 0x2a, 0x00, 0xc5, 0x02,
];
const TAG: &'static str = "板块文件大小";
const LEN: usize = 12 + 40;
fn send(&mut self) -> &[u8] {
&self.send
}
fn parse(&mut self, v: Vec<u8>) {
if v.len() >= 4 {
self.size = u32::from_le_bytes([v[0], v[1], v[2], v[3]]);
}
self.response = v;
}
fn result(&self) -> &Self::Item {
&self.size
}
}
#[derive(Debug, Clone)]
pub struct BlockInfoChunk {
pub send: Box<[u8]>,
pub response: Vec<u8>,
pub data: Vec<u8>,
}
impl BlockInfoChunk {
pub fn new(block_file: &str, start: u32, size: u32) -> Self {
let mut send = [0u8; Self::LEN];
send[0..12].copy_from_slice(Self::SEND);
send[12..16].copy_from_slice(&start.to_le_bytes());
send[16..20].copy_from_slice(&size.to_le_bytes());
let name = block_file.as_bytes();
let n = name.len().min(100);
send[20..20 + n].copy_from_slice(&name[..n]);
Self {
send: send.into(),
response: Vec::new(),
data: Vec::new(),
}
}
}
impl Tdx for BlockInfoChunk {
type Item = [u8];
const SEND: &'static [u8] = &[
0x0c, 0x37, 0x18, 0x6a, 0x00, 0x01, 0x6e, 0x00, 0x6e, 0x00, 0xb9, 0x06,
];
const TAG: &'static str = "板块文件内容";
const LEN: usize = 12 + 4 + 4 + 100;
fn send(&mut self) -> &[u8] {
&self.send
}
fn parse(&mut self, v: Vec<u8>) {
self.data = v.iter().skip(4).copied().collect();
self.response = v;
}
fn result(&self) -> &Self::Item {
&self.data
}
}
pub fn get_block_info(
tcp: &mut crate::tcp::Tcp,
block_file: &str,
) -> crate::Result<Vec<BlockRecord>> {
Ok(parse_block_content(&download_file(tcp, block_file)?))
}
pub fn download_file(tcp: &mut crate::tcp::Tcp, file: &str) -> crate::Result<Vec<u8>> {
let mut meta = BlockInfoMeta::new(file);
meta.recv_parsed(tcp)?;
let size = *meta.result();
const ONE_CHUNK: u32 = 0x7530;
let mut content = Vec::with_capacity(size as usize);
for seg in 0..size.div_ceil(ONE_CHUNK) {
let start = seg * ONE_CHUNK;
let mut chunk = BlockInfoChunk::new(file, start, ONE_CHUNK.min(size - start));
chunk.recv_parsed(tcp)?;
content.extend_from_slice(chunk.result());
}
Ok(content)
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, serde::Serialize)]
pub enum BlockKind {
Concept,
Style,
Index,
}
#[derive(Debug, Clone, PartialEq, serde::Serialize)]
pub struct Block {
pub kind: BlockKind,
pub name: String,
pub index_code: Option<String>,
pub created: Option<u32>,
pub updated: Option<u32>,
pub stocks: Vec<(u16, String)>,
}
pub fn get_blocks(tcp: &mut crate::tcp::Tcp) -> crate::Result<Vec<Block>> {
Ok(parse_blocks(&download_file(tcp, "infoharbor_block.dat")?)?)
}
pub fn parse_blocks(data: &[u8]) -> std::io::Result<Vec<Block>> {
let invalid = |msg: String| std::io::Error::new(std::io::ErrorKind::InvalidData, msg);
let text = crate::tcp::helper::gbk_to_string(data);
let mut blocks: Vec<(Block, Option<usize>)> = Vec::new();
for line in text.lines().map(str::trim).filter(|l| !l.is_empty()) {
if let Some(head) = line.strip_prefix('#') {
let mut fields = head.split(',').map(str::trim);
let tag = fields.next().unwrap_or_default();
let (kind, name) = match tag.split_once('_') {
Some(("GN", name)) => (BlockKind::Concept, name),
Some(("FG", name)) => (BlockKind::Style, name),
Some(("ZS", name)) => (BlockKind::Index, name),
_ => return Err(invalid(format!("无法识别的板块头: {line}"))),
};
let declared = fields.next().and_then(|s| s.parse().ok());
let index_code = fields.next().filter(|s| !s.is_empty()).map(str::to_owned);
let mut date = || {
fields
.next()
.and_then(|s| s.parse().ok())
.filter(|d| *d > 0)
};
let (created, updated) = (date(), date());
let block = Block {
kind,
name: name.to_owned(),
index_code,
created,
updated,
stocks: Vec::with_capacity(declared.unwrap_or(0)),
};
blocks.push((block, declared));
} else {
let Some((block, _)) = blocks.last_mut() else {
return Err(invalid(format!("成分行出现在板块头之前: {line}")));
};
for item in line.split(',').filter(|s| !s.is_empty()) {
let stock = item
.split_once('#')
.and_then(|(m, code)| Some((m.parse().ok()?, code.to_owned())))
.ok_or_else(|| invalid(format!("无法识别的成分: {item}")))?;
block.stocks.push(stock);
}
}
}
blocks
.into_iter()
.map(|(block, declared)| match declared {
Some(n) if n != block.stocks.len() => Err(invalid(format!(
"板块「{}」声明 {n} 只成分,实际 {} 只(文件可能不完整)",
block.name,
block.stocks.len()
))),
_ => Ok(block),
})
.collect()
}
pub fn parse_block_content(data: &[u8]) -> Vec<BlockRecord> {
let mut result = Vec::new();
if data.len() < 386 {
return result;
}
let num = u16_from_le_bytes(data, 384) as usize;
if num == 0 {
return result;
}
let slot = (data.len() - 386).div_ceil(num);
for i in 0..num {
let mut pos = 386 + i * slot;
if pos + 13 > data.len() {
break;
}
let name_raw = &data[pos..pos + 9];
let blockname = crate::tcp::helper::gbk_to_string_trim_null(name_raw);
let stock_count = u16_from_le_bytes(data, pos + 9) as usize;
let block_type = u16_from_le_bytes(data, pos + 11);
pos += 13;
if blockname.is_empty() || stock_count == 0 {
continue; }
for _ in 0..stock_count {
if pos + 7 > data.len() {
break;
}
let code_raw = &data[pos..pos + 6];
pos += 7;
let code: String = code_raw
.iter()
.map(|&b| b as char)
.filter(|c| c.is_ascii_digit())
.collect();
if code.len() == 6 {
result.push(BlockRecord {
blockname: blockname.clone(),
block_type,
code,
});
}
}
}
result
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn parse_block_content_two_blocks() {
let slot: usize = 13 + 14;
let mut data = vec![0u8; 384];
data.extend_from_slice(&2u16.to_le_bytes());
let mut b0 = vec![0u8; slot];
b0[..6].copy_from_slice(&[0xef, 0xae, 0xb5, 0xe7, 0xb3, 0xd8]);
b0[9..11].copy_from_slice(&2u16.to_le_bytes());
b0[11..13].copy_from_slice(&1u16.to_le_bytes());
b0[13..19].copy_from_slice(b"300750");
b0[20..26].copy_from_slice(b"600519");
data.extend_from_slice(&b0);
let mut b1 = vec![0u8; slot];
b1[..5].copy_from_slice(b"HS300");
b1[9..11].copy_from_slice(&1u16.to_le_bytes());
b1[11..13].copy_from_slice(&0u16.to_le_bytes());
b1[13..19].copy_from_slice(b"000001");
data.extend_from_slice(&b1);
let records = parse_block_content(&data);
assert_eq!(records.len(), 3);
assert_eq!(records[0].blockname, "锂电池");
assert_eq!(records[0].code, "300750");
assert_eq!(records[0].block_type, 1);
assert_eq!(records[1].blockname, "锂电池");
assert_eq!(records[1].code, "600519");
assert_eq!(records[2].blockname, "HS300");
assert_eq!(records[2].code, "000001");
}
#[test]
fn parse_truncated_returns_empty() {
assert!(parse_block_content(&[0u8; 100]).is_empty());
}
#[test]
fn test_meta_send_bytes() {
let meta = BlockInfoMeta::new("block_gn.dat");
assert_eq!(meta.send.len(), 52);
assert_eq!(&meta.send[12..24], b"block_gn.dat");
assert_eq!(&meta.send[24..52], &[0u8; 28]);
}
#[test]
fn parse_blocks_text() {
let text = "#GN_人工智能,5,880948,20170314,20261103,,\r\n0#000032,0#000034,\r\n1#600000,1#688981,2#920799,\r\n\
#FG_破净资产,0,,20050607,,,\r\n\
#ZS_上证50,1,880529,20050607,20260512,,\r\n1#600519,\r\n";
let (gbk, _, _) = encoding_rs::GBK.encode(text);
let blocks = super::parse_blocks(&gbk).unwrap();
assert_eq!(blocks.len(), 3);
let ai = &blocks[0];
assert_eq!(
(ai.kind, ai.name.as_str()),
(super::BlockKind::Concept, "人工智能")
);
assert_eq!(ai.index_code.as_deref(), Some("880948"));
assert_eq!((ai.created, ai.updated), (Some(20170314), Some(20261103)));
assert_eq!(
ai.stocks,
[
(0, "000032"),
(0, "000034"),
(1, "600000"),
(1, "688981"),
(2, "920799")
]
.map(|(m, c)| (m, c.to_string()))
);
let empty = &blocks[1];
assert_eq!(empty.kind, super::BlockKind::Style);
assert_eq!(
(empty.index_code.clone(), empty.updated, empty.stocks.len()),
(None, None, 0)
);
assert_eq!(blocks[2].kind, super::BlockKind::Index);
}
#[test]
fn parse_blocks_rejects_incomplete_or_malformed() {
for text in [
"#GN_芯片,3,880952,20170907,20261118,,\n0#000021,0#000063,\n", "#XX_未知,1,,,,\n0#000001,\n", "0#000001,\n", "#GN_芯片,1,880952,,,,\nabc,\n", ] {
let (gbk, _, _) = encoding_rs::GBK.encode(text);
let err = super::parse_blocks(&gbk).unwrap_err();
assert_eq!(err.kind(), std::io::ErrorKind::InvalidData, "{text}");
}
assert!(super::parse_blocks(b"").unwrap().is_empty());
}
}