sheet.rs

//! シートを行ごとに読む
//!
//! `<sheetData>` の中を順にたどり、`</row>` に当たるたびに 1 行返す。
//! シート全体をメモリに置かないので、展開すると数 GB になるシートでも読める。
//!
//! ```no_run
//! use folio::book::Book;
//! use std::path::Path;
//!
//! let mut book = Book::open(Path::new("data.xlsx")).unwrap();
//! let mut sheet = book.read("Sheet1").unwrap();
//!
//! while let Some(row) = sheet.read().unwrap() {
//!     for cell in &row.cell {
//!         println!("{} {:?}", cell.column, cell.value);
//!     }
//! }
//! ```
//!
//! # バイトのまま走査する
//!
//! シートも XML だが、汎用の読み取り ([`crate::xml::Reader`]) は通さず、`scan` モジュールの道具で
//! バイトのまま走査する。シートの中身のほとんどは `<c r="B2" s="1"><v>12</v></c>` のような
//! 短い並びなので、要る属性と値だけを拾うほうがずっと速い。
//! この形のセルには、さらに近道を用意してある (`quick_cell`)。
//!
//! 行は、受け取ったバイトの中で `</row>` まで見えたときにだけ組み立て終える。
//! 途中で足りなくなったら、続きを受け取って、その行の頭から読み直す。
//!
//! # 入れ物を使い回す
//!
//! 返す行は毎回同じ入れ物である。前の行のセルが持っていた文字の入れ物は、次の行でも使う。
//! 文字のセルごとに入れ物を作って捨てる手間が、ほとんどなくなる。
//!
//! # 空のセル
//!
//! 値はないが書式だけ付いているセルも、そのまま返す。ファイルに書いてあるとおりに返し、
//! 落とすかどうかは読む側が決める。

use crate::cell::{Cell, Row, Value};
use crate::error::Error;
use crate::scan::{self, Feed, Mark, find, local, space, starts, trim, utf8};
use crate::shared::{self, Shared};
use crate::style::Style;
use crate::zip;
use std::sync::Arc;


/// 10 の累乗。どれも f64 でちょうど表せる
const POWER: [f64; 16] = [
    1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, 1e10, 1e11, 1e12, 1e13, 1e14, 1e15,
];


/// どちらの形式から読むか
enum Origin {
    /// xlsx。`<sheetData>` の中をバイトのまま走査する
    Sheet(Scan),
    /// xls。BIFF のレコードを順にたどる
    Record(crate::xls::Cursor),
}


/// シートを行ごとに読むもの
pub struct Reader {
    source: Origin,
    shared: Arc<Shared>,
    style: Arc<Style>,
    /// 1904 年方式かどうか。日付を読む側が要る
    epoch1904: bool,
    /// 読み終えたか
    ended: bool,
    row: Row,
}


impl Reader {
    /// xlsx のシートのパートを読む用意をする
    pub fn new(source: zip::Reader, shared: Arc<Shared>, style: Arc<Style>, epoch1904: bool) -> Reader {
        Reader {
            source: Origin::Sheet(Scan::new(source)),
            shared,
            style,
            epoch1904,
            ended: false,
            row: Row::default(),
        }
    }

    /// xls のシートの区画を読む用意をする
    pub fn over(
        source: crate::xls::Cursor,
        shared: Arc<Shared>,
        style: Arc<Style>,
        epoch1904: bool,
    ) -> Reader {
        Reader {
            source: Origin::Record(source),
            shared,
            style,
            epoch1904,
            ended: false,
            row: Row::default(),
        }
    }

    /// 書式の対応。日付かどうかを見るのに使う
    ///
    /// 持ち手ごと渡す。[`Reader::read`] が返す行はこの Reader を借りているので、
    /// 参照で返すと行を見ているあいだに書式を引けなくなるためである。
    pub fn style(&self) -> Arc<Style> {
        self.style.clone()
    }

    /// 1904 年方式かどうか
    pub fn epoch1904(&self) -> bool {
        self.epoch1904
    }

    /// 次の行。終わったら None
    pub fn read(&mut self) -> Result<Option<&Row>, Error> {
        if self.ended {
            return Ok(None);
        }

        let found = match &mut self.source {
            Origin::Sheet(scan) => scan.read(&mut self.row, &self.shared)?,
            Origin::Record(cursor) => cursor.read(&mut self.row, &self.shared)?,
        };

        if !found {
            self.ended = true;
            return Ok(None);
        }

        Ok(Some(&self.row))
    }
}


/// xlsx のシートを、バイトのまま走査するもの
struct Scan {
    feed: Feed,
    /// `<sheetData>` の中に入ったか
    inside: bool,
    /// 直前の行番号。`r` のない行のために持つ
    last: u32,
    /// 実体参照を戻した値を組み立てるところ
    scratch: String,
}


impl Scan {
    fn new(source: zip::Reader) -> Scan {
        Scan {feed: Feed::new(source), inside: false, last: 0, scratch: String::new()}
    }

    /// 次の行を row に組み立てる。行があれば true
    fn read(&mut self, row: &mut Row, shared: &Shared) -> Result<bool, Error> {
        loop {
            let data = self.feed.data();

            let step = if self.inside {
                row_step(data, row, shared, self.last, &mut self.scratch)?
            } else {
                head_step(data)
            };

            match step {
                Step::Head(used, empty) => {
                    self.feed.advance(used);

                    if empty {
                        self.feed.finish()?;
                        return Ok(false);
                    }

                    self.inside = true;
                }

                Step::Row(used, number) => {
                    self.feed.advance(used);
                    self.last = number;
                    return Ok(true);
                }

                Step::End => {
                    self.feed.finish()?;
                    return Ok(false);
                }

                Step::More(used) => {
                    self.feed.advance(used);

                    if !self.feed.fill()? {
                        if self.inside && !self.feed.blank() {
                            return Err(Error::new("シートが途中で終わっています"));
                        }

                        return Ok(false);
                    }
                }
            }
        }
    }
}


/// 走査を 1 歩進めた結果
enum Step {
    /// `<sheetData>` を見つけた。読んだバイト数と、その場で閉じていたか
    Head(usize, bool),
    /// 行を 1 つ組み立てた。読んだバイト数と、その行の番号
    Row(usize, u32),
    /// `</sheetData>` に着いた
    End,
    /// データが足りない。前から捨ててよいバイト数
    More(usize),
}


/// `<sheetData>` の開くタグを探す
fn head_step(data: &[u8]) -> Step {
    let mut at = 0;

    loop {
        let Some(open) = find(data, at, b'<') else {
            return Step::More(data.len());
        };

        match scan::mark(data, open) {
            Mark::More => return Step::More(open),
            Mark::Skip(next) | Mark::Data(_, _, next) | Mark::Close(next, _, _) => at = next,

            Mark::Open(bracket, from, to) => {
                if local(&data[from..to]) == b"sheetData" {
                    return Step::Head(bracket + 1, data[bracket - 1] == b'/');
                }

                at = bracket + 1;
            }
        }
    }
}


/// 次の行を読んで、row に組み立てる
fn row_step(data: &[u8], row: &mut Row, shared: &Shared, last: u32, scratch: &mut String) -> Result<Step, Error> {
    let mut at = 0;

    loop {
        let Some(open) = find(data, at, b'<') else {
            return Ok(Step::More(data.len()));
        };

        match scan::mark(data, open) {
            Mark::More => return Ok(Step::More(open)),
            Mark::Skip(next) | Mark::Data(_, _, next) => at = next,

            Mark::Close(next, from, to) => {
                if local(&data[from..to]) == b"sheetData" {
                    return Ok(Step::End);
                }

                at = next;
            }

            Mark::Open(bracket, from, to) => {
                // sheetData の中には行しか来ないはずだが、ほかの要素が来たら中身ごと飛ばす
                if local(&data[from..to]) != b"row" {
                    match scan::skip(data, bracket, from, to) {
                        Some(next) => at = next,
                        None => return Ok(Step::More(open)),
                    }

                    continue;
                }

                return match read_row(data, bracket, to, row, shared, last, scratch)? {
                    Some((next, number)) => Ok(Step::Row(next, number)),
                    None => Ok(Step::More(open)),
                };
            }
        }
    }
}


/// `<row>` の開くタグから `</row>` までを読んで、row に組み立てる
///
/// bracket は開くタグの '>' の位置、name_end は名前の終わりである。
/// 読み終えた位置と行番号を返す。行が最後まで届いていなければ None で、そのときの row は使わない。
fn read_row(
    data: &[u8],
    bracket: usize,
    name_end: usize,
    row: &mut Row,
    shared: &Shared,
    last: u32,
    scratch: &mut String,
) -> Result<Option<(usize, u32)>, Error> {
    let empty = data[bracket - 1] == b'/';
    let stop = if empty {bracket - 1} else {bracket};
    let following = last.saturating_add(1);
    let mut number = following;
    let mut cursor = name_end;

    while let Some((key, value, next)) = scan::attribute(data, cursor, stop)? {
        if key == b"r" {
            number = unsigned(value).unwrap_or(following);
        }

        cursor = next;
    }

    row.number = number;

    if empty {
        row.cell.clear();
        return Ok(Some((bracket + 1, number)));
    }

    let mut count = 0;
    let mut column = 0;
    let mut at = bracket + 1;

    loop {
        let Some(open) = find(data, at, b'<') else {
            return Ok(None);
        };

        // よくある形のセルは近道で読む
        if data.get(open + 1) == Some(&b'c') && data.get(open + 2) == Some(&b' ') {
            if count == row.cell.len() {
                row.cell.push(Cell {column: 0, style: 0, value: Value::Empty, formula: String::new()});
            }

            match quick_cell(data, open, &mut row.cell[count], &mut column, shared)? {
                Quick::Done(next) => {
                    at = next;
                    count += 1;
                    continue;
                }

                Quick::More => return Ok(None),
                Quick::Other => {}
            }
        }

        match scan::mark(data, open) {
            Mark::More => return Ok(None),
            Mark::Skip(next) | Mark::Data(_, _, next) => at = next,

            Mark::Close(next, from, to) => {
                if local(&data[from..to]) == b"row" {
                    row.cell.truncate(count);
                    return Ok(Some((next, number)));
                }

                at = next;
            }

            Mark::Open(inner, from, to) => {
                if local(&data[from..to]) != b"c" {
                    match scan::skip(data, inner, from, to) {
                        Some(next) => at = next,
                        None => return Ok(None),
                    }

                    continue;
                }

                if count == row.cell.len() {
                    row.cell.push(Cell {column: 0, style: 0, value: Value::Empty, formula: String::new()});
                }

                match read_cell(data, inner, to, &mut row.cell[count], &mut column, shared, scratch)? {
                    Some(next) => {
                        at = next;
                        count += 1;
                    }

                    None => return Ok(None),
                }
            }
        }
    }
}


/// 近道で読んだ結果
enum Quick {
    /// 読み終えた。次に読む位置
    Done(usize),
    /// 近道の受け持つ形ではない
    Other,
    /// データが足りない
    More,
}


/// よくある形のセルを近道で読む
///
/// 受け持つのは、`<c 属性>` のあとに `<v>値</v></c>` が続くものと、`<c 属性/>` だけである。
/// 属性は引用符を見ながら 1 回で読み、タグの終わりを別に探さない。
/// それ以外の形 (数式、その場の文字、実体参照、空白の混じり) は Quick::Other を返し、
/// ふつうの読み方に任せる。そのときは cell も column も変えない。
fn quick_cell(data: &[u8], open: usize, cell: &mut Cell, column: &mut u32, shared: &Shared) -> Result<Quick, Error> {
    let mut at = open + 2;
    let mut reference: Option<(usize, usize)> = None;
    let mut style = 0;
    let mut kind = Kind::Number;

    let empty = loop {
        while at < data.len() && space(data[at]) {
            at += 1;
        }

        let Some(byte) = data.get(at) else {
            return Ok(Quick::More);
        };

        if *byte == b'>' {
            at += 1;
            break false;
        }

        if *byte == b'/' {
            match data.get(at + 1) {
                None => return Ok(Quick::More),
                Some(b'>') => {
                    at += 2;
                    break true;
                }
                Some(_) => return Ok(Quick::Other),
            }
        }

        let key = at;

        while at < data.len() && data[at] != b'=' {
            if space(data[at]) || matches!(data[at], b'>' | b'"' | b'\'' | b'/') {
                return Ok(Quick::Other);
            }

            at += 1;
        }

        let Some(quote) = data.get(at + 1) else {
            return Ok(Quick::More);
        };

        if *quote != b'"' && *quote != b'\'' {
            return Ok(Quick::Other);
        }

        let from = at + 2;

        let Some(to) = find(data, from, *quote) else {
            return Ok(Quick::More);
        };

        match local(&data[key..at]) {
            b"r" => reference = Some((from, to)),
            b"s" => style = unsigned(&data[from..to]).unwrap_or(0),
            b"t" => kind = Kind::of(&data[from..to]),
            _ => {}
        }

        at = to + 1;
    };

    let next = match reference {
        Some((from, to)) => column_of(&data[from..to]),
        None => column.saturating_add(1),
    };

    if empty {
        *column = next;
        cell.column = next;
        cell.style = style;
        cell.formula.clear();
        cell.value = Value::Empty;
        return Ok(Quick::Done(at));
    }

    match starts(data, at, b"<v>") {
        None => return Ok(Quick::More),
        Some(false) => return Ok(Quick::Other),
        Some(true) => {}
    }

    let from = at + 3;

    let Some(to) = find(data, from, b'<') else {
        return Ok(Quick::More);
    };

    match starts(data, to, b"</v></c>") {
        None => return Ok(Quick::More),
        Some(false) => return Ok(Quick::Other),
        Some(true) => {}
    }

    let raw = &data[from..to];

    if raw.contains(&b'&') {
        return Ok(Quick::Other);
    }

    *column = next;
    cell.column = next;
    cell.style = style;
    cell.formula.clear();
    let text = take_text(&mut cell.value);
    cell.value = build(kind, raw, text, shared)?;
    Ok(Quick::Done(to + 8))
}


/// `<c>` の開くタグから `</c>` までを読んで、cell に入れる
///
/// bracket は開くタグの '>' の位置、name_end は名前の終わりである。
/// 読み終えた位置を返す。データが足りなければ None
fn read_cell(
    data: &[u8],
    bracket: usize,
    name_end: usize,
    cell: &mut Cell,
    column: &mut u32,
    shared: &Shared,
    scratch: &mut String,
) -> Result<Option<usize>, Error> {
    let empty = data[bracket - 1] == b'/';
    let stop = if empty {bracket - 1} else {bracket};
    let mut reference = None;
    let mut style = 0;
    let mut kind = Kind::Number;
    let mut cursor = name_end;

    while let Some((key, value, next)) = scan::attribute(data, cursor, stop)? {
        match key {
            b"r" => reference = Some(value),
            b"s" => style = unsigned(value).unwrap_or(0),
            b"t" => kind = Kind::of(value),
            _ => {}
        }

        cursor = next;
    }

    *column = match reference {
        Some(value) => column_of(value),
        None => column.saturating_add(1),
    };

    cell.column = *column;
    cell.style = style;
    cell.formula.clear();
    let mut text = take_text(&mut cell.value);

    if empty {
        return Ok(Some(bracket + 1));
    }

    // `<v>` の中身。実体参照を戻したときは scratch に入っている
    let mut value: Option<(usize, usize)> = None;
    let mut decoded = false;
    let mut at = bracket + 1;

    loop {
        let Some(open) = find(data, at, b'<') else {
            return Ok(None);
        };

        match scan::mark(data, open) {
            Mark::More => return Ok(None),
            Mark::Skip(next) | Mark::Data(_, _, next) => at = next,

            Mark::Close(next, from, to) => {
                if local(&data[from..to]) == b"c" {
                    let raw: &[u8] = if decoded {
                        scratch.as_bytes()
                    } else {
                        match value {
                            Some((from, to)) => &data[from..to],
                            None => &[],
                        }
                    };

                    cell.value = build(kind, raw, text, shared)?;
                    return Ok(Some(next));
                }

                at = next;
            }

            Mark::Open(inner, from, to) => {
                let closed = data[inner - 1] == b'/';

                match local(&data[from..to]) {
                    b"v" if !closed => {
                        scratch.clear();

                        let Some((range, next)) = scan::content(data, inner + 1, scratch)? else {
                            return Ok(None);
                        };

                        value = range;
                        decoded = range.is_none();
                        at = next;
                    }

                    b"f" if !closed => {
                        let Some((range, next)) = scan::content(data, inner + 1, &mut cell.formula)? else {
                            return Ok(None);
                        };

                        if let Some((from, to)) = range {
                            cell.formula.push_str(utf8(&data[from..to])?);
                        }

                        at = next;
                    }

                    b"is" if !closed => {
                        let Some(next) = scan::rich(data, inner + 1, b"is", &mut text)? else {
                            return Ok(None);
                        };

                        at = next;
                    }

                    _ => match scan::skip(data, inner, from, to) {
                        Some(next) => at = next,
                        None => return Ok(None),
                    },
                }
            }
        }
    }
}


/// セルの `t` が表す種類
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum Kind {
    Number,
    SharedText,
    PlainText,
    InlineText,
    Boolean,
    Failure,
}


impl Kind {
    fn of(value: &[u8]) -> Kind {
        match value {
            b"s" => Kind::SharedText,
            b"str" | b"d" => Kind::PlainText,
            b"inlineStr" => Kind::InlineText,
            b"b" => Kind::Boolean,
            b"e" => Kind::Failure,
            _ => Kind::Number,
        }
    }
}


/// 集めたものから値を作る
///
/// raw は `<v>` の中身である。text は文字の値に使う入れ物で、`<is>` の文字が入っていることもある。
fn build(kind: Kind, raw: &[u8], mut text: String, shared: &Shared) -> Result<Value, Error> {
    let value = match kind {
        Kind::SharedText => match unsigned(raw) {
            Some(index) => {
                text.clear();
                text.push_str(shared.get(index));
                Value::Text(text)
            }

            None => Value::Empty,
        },

        Kind::PlainText => {
            text.clear();
            shared::decode_into(utf8(raw)?, &mut text);
            Value::Text(text)
        }

        Kind::InlineText => {
            if text.contains("_x") {
                Value::Text(shared::decode(&text))
            } else {
                Value::Text(text)
            }
        }

        Kind::Boolean => Value::Boolean(utf8(raw)?.trim() == "1"),
        Kind::Failure => Value::Error(utf8(raw)?.trim().to_string()),

        Kind::Number => {
            if let Some(number) = simple_number(trim(raw)) {
                return Ok(Value::Number(number));
            }

            // よくある形でないものは、標準の読み方に任せる。数として読めなければ文字のまま返す
            let body = utf8(raw)?.trim();

            if body.is_empty() {
                Value::Empty
            } else {
                match body.parse::<f64>() {
                    Ok(number) => Value::Number(number),
                    Err(_) => Value::Text(body.to_string()),
                }
            }
        }
    };

    Ok(value)
}


/// 値が文字なら、その入れ物を空にして取り出す。文字でなければ新しく作る
///
/// 取り出したあとの値は空になる。
fn take_text(value: &mut Value) -> String {
    match std::mem::replace(value, Value::Empty) {
        Value::Text(mut text) => {
            text.clear();
            text
        }

        _ => String::new(),
    }
}


/// 符号のない整数として読む。前後の空白は落とす。読めなければ None
pub(crate) fn unsigned(text: &[u8]) -> Option<u32> {
    let digit = trim(text);

    // 9 桁までの数字だけなら、あふれる心配がないのでその場で数える
    if !digit.is_empty() && digit.len() <= 9 && digit.iter().all(|byte| byte.is_ascii_digit()) {
        return Some(digit.iter().fold(0, |sum, byte| sum * 10 + (byte - b'0') as u32));
    }

    std::str::from_utf8(text).ok()?.trim().parse().ok()
}


/// よくある形の数を読む。符号、整数部、小数部だけで、数字が 15 桁以内のもの
///
/// 15 桁以内の整数は f64 でちょうど表せ、10 の 15 乗までもちょうど表せる。
/// だから割り算 1 回で、正しく丸めた値になる。標準の読み方と同じ値である。
/// それ以外の形 (指数、16 桁以上、+ の符号) は None を返し、標準の読み方に任せる。
fn simple_number(text: &[u8]) -> Option<f64> {
    let (negative, body) = match text.first() {
        Some(b'-') => (true, &text[1..]),
        _ => (false, text),
    };

    let mut mantissa: u64 = 0;
    let mut digit = 0;
    let mut fraction = 0;
    let mut point = false;

    for byte in body {
        if byte.is_ascii_digit() {
            mantissa = mantissa * 10 + (byte - b'0') as u64;
            digit += 1;

            if point {
                fraction += 1;
            }

            if digit > 15 {
                return None;
            }
        } else if *byte == b'.' && !point {
            point = true;
        } else {
            return None;
        }
    }

    if digit == 0 {
        return None;
    }

    let value = mantissa as f64 / POWER[fraction];
    Some(if negative {-value} else {value})
}


/// A1 の形の参照から列を読む。1 から始まる。読めなければ 0
fn column_of(reference: &[u8]) -> u32 {
    let mut result: u32 = 0;

    for byte in reference {
        if !byte.is_ascii_alphabetic() {
            break;
        }

        result = result.wrapping_mul(26).wrapping_add((byte.to_ascii_uppercase() - b'A' + 1) as u32);
    }

    result
}