package.rs

//! OPC の層。パートと関係
//!
//! docx、xlsx、pptx はどれも同じ包み方をしている。ZIP の中に
//! `[Content_Types].xml` と `_rels/*.rels` があり、本体はパートとして並んでいる。
//! どのパートがどのパートを指しているかは `.rels` に書いてあり、
//! 名前ではなく関係の型 ([`OFFICE_DOCUMENT`] など) でたどるのが正しい引き方である。
//!
//! # 触っていないパートを残す
//!
//! [`Writer::carry`] は、直すパートを除いた全部を圧縮したまま写す。
//! folio が中身を知らないパート (グラフ、ピボット、画像、条件付き書式) も、そのまま残る。
//! 写す順も元のままなので、`[Content_Types].xml` が先頭に来る並びも崩れない。

use crate::error::Error;
use crate::xml::{Event, Reader};
use crate::zip::{self, Archive, Writer as ZipWriter};
use std::collections::HashSet;
use std::path::Path;


/// 本体のパートを指す関係の型
pub const OFFICE_DOCUMENT: &str =
    "http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument";

/// 関係の名前空間の前置き。短い形で書かれていることもある
const RELATIONSHIP_PREFIX: &str = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/";


/// パートからパートへの関係
#[derive(Debug, Clone)]
pub struct Relationship {
    /// パートの中から指すときの名前
    pub id: String,
    /// 何としてつながっているか
    pub kind: String,
    /// 指し先。外部でなければパッケージの先頭からの名前に直してある
    pub target: String,
    /// 指し先がパッケージの外か
    pub external: bool,
}


impl Relationship {
    /// 型が合うか。前置きを省いた短い形でも引けるようにする
    pub fn is(&self, kind: &str) -> bool {
        if self.kind == kind {
            return true;
        }

        match self.kind.strip_prefix(RELATIONSHIP_PREFIX) {
            Some(tail) => tail == kind,
            None => false,
        }
    }
}


/// 読むために開いたパッケージ
pub struct Package {
    pub(crate) archive: Archive,
}


impl Package {
    /// ファイルを開く
    pub fn open(path: &Path) -> Result<Package, Error> {
        Ok(Package {archive: Archive::open(path)?})
    }

    /// そのパートがあるか
    pub fn has(&self, name: &str) -> bool {
        self.archive.has(name)
    }

    /// 入っているパートの名前
    pub fn name(&self) -> Vec<&str> {
        self.archive.entry().iter().map(|one| one.name.as_str()).collect()
    }

    /// パートの中身を全部読む
    pub fn read(&mut self, name: &str) -> Result<Vec<u8>, Error> {
        self.archive.read(name)
    }

    /// パートを XML として順に読む
    pub fn reader(&mut self, name: &str) -> Result<Reader, Error> {
        Ok(Reader::new(self.archive.reader(name)?))
    }

    /// そのパートが持っている関係。パッケージ自身の関係は空文字を渡す
    pub fn relationship(&mut self, part: &str) -> Result<Vec<Relationship>, Error> {
        let name = rels_name(part);

        if !self.archive.has(&name) {
            return Ok(Vec::new());
        }

        let data = self.archive.read(&name)?;
        let mut reader = Reader::over(data);
        let mut result = Vec::new();

        while let Some(event) = reader.next().map_err(|error| error.within(&name))? {
            if event != Event::Open && event != Event::Empty {
                continue;
            }

            if reader.name() != "Relationship" {
                continue;
            }

            let id = reader.attribute("Id").unwrap_or("").to_string();
            let kind = reader.attribute("Type").unwrap_or("").to_string();
            let target = reader.attribute("Target").unwrap_or("");
            let external = reader.attribute("TargetMode") == Some("External");

            result.push(Relationship {
                id,
                kind,
                target: if external {target.to_string()} else {resolve(part, target)},
                external,
            });
        }

        Ok(result)
    }

    /// 型でつながっている先を 1 つ引く
    pub fn target(&mut self, part: &str, kind: &str) -> Result<Option<String>, Error> {
        for one in self.relationship(part)? {
            if one.is(kind) && !one.external {
                return Ok(Some(one.target));
            }
        }

        Ok(None)
    }

    /// 本体のパートの名前
    pub fn main(&mut self) -> Result<String, Error> {
        match self.target("", OFFICE_DOCUMENT)? {
            Some(name) => Ok(name),
            None => Err(Error::new("本体のパートが見つかりません")),
        }
    }
}


/// 書くために開いたパッケージ
pub struct Writer {
    zip: ZipWriter,
    written: HashSet<String>,
}


impl Writer {
    /// 新しいファイルを作る
    pub fn create(path: &Path) -> Result<Writer, Error> {
        Ok(Writer {zip: ZipWriter::create(path)?, written: HashSet::new()})
    }

    /// パートを 1 つ書く
    pub fn add(&mut self, name: &str, data: &[u8]) -> Result<(), Error> {
        self.claim(name)?;
        self.zip.add(name, data)
    }

    /// 縮めずにパートを 1 つ書く。すでに縮んでいる画像などに使う
    pub fn add_stored(&mut self, name: &str, data: &[u8]) -> Result<(), Error> {
        self.claim(name)?;
        self.zip.add_stored(name, data)
    }

    /// 長さの決まっていないパートを書き始める
    pub fn start(&mut self, name: &str) -> Result<(), Error> {
        self.claim(name)?;
        self.zip.start(name)
    }

    /// 書き始めたパートに続きを渡す
    pub fn write(&mut self, data: &[u8]) -> Result<(), Error> {
        self.zip.write(data)
    }

    /// 書き始めたパートを閉じる
    pub fn close(&mut self) -> Result<(), Error> {
        self.zip.close()
    }

    /// 元のパッケージから、skip にないパートを圧縮したまま写す
    pub fn carry(&mut self, source: &mut Package, skip: &[&str]) -> Result<(), Error> {
        let all: Vec<String> = source.archive.entry().iter().map(|one| one.name.clone()).collect();

        for name in all {
            if self.written.contains(&name) || skip.contains(&name.as_str()) {
                continue;
            }

            self.written.insert(name.clone());
            self.zip.copy(&mut source.archive, &name)?;
        }

        Ok(())
    }

    /// 中央目録を書いて閉じる
    pub fn finish(self) -> Result<(), Error> {
        self.zip.finish()
    }

    /// 同じ名前を二度書かないようにする
    fn claim(&mut self, name: &str) -> Result<(), Error> {
        if !self.written.insert(name.to_string()) {
            return Err(Error::at("同じパートを二度書こうとしています", name));
        }

        Ok(())
    }
}


/// そのパートの関係が書いてあるパートの名前
pub fn rels_name(part: &str) -> String {
    match part.rfind('/') {
        Some(cut) => format!("{}/_rels/{}.rels", &part[..cut], &part[cut + 1..]),
        None if part.is_empty() => "_rels/.rels".to_string(),
        None => format!("_rels/{part}.rels"),
    }
}


/// 指し先を、パッケージの先頭からの名前に直す
pub fn resolve(part: &str, target: &str) -> String {
    if let Some(tail) = target.strip_prefix('/') {
        return tail.to_string();
    }

    let base = match part.rfind('/') {
        Some(cut) => &part[..cut],
        None => "",
    };

    let mut piece: Vec<&str> = if base.is_empty() {
        Vec::new()
    } else {
        base.split('/').collect()
    };

    for step in target.split('/') {
        match step {
            "" | "." => {}
            ".." => {
                piece.pop();
            }
            _ => piece.push(step),
        }
    }

    piece.join("/")
}


/// パートの、印より前と後ろ
pub struct Split {
    /// 開く印より前
    pub head: Vec<u8>,
    /// 閉じる印より後ろ
    pub tail: Vec<u8>,
    /// 捨てた中身のうち、末尾に近いところ。keep バイトまで
    pub last: Vec<u8>,
    /// 開く印が見つかったか
    pub found: bool,
}


/// パートを読み流して、印より前と後ろを取り出す
///
/// 中身だけを書き直したいときに使う。xlsx なら `<sheetData>`、docx なら `<w:body>`、
/// pptx なら `<p:spTree>` が印になる。前と後ろに入っている、folio が組み立てないもの
/// (列幅、用紙の指定、背景、切り替え) は、そのまま残せる。
///
/// 中身は捨てるが、末尾に近い keep バイトだけは [`Split::last`] に残す。
/// docx のように、閉じる印の直前に採っておきたいものがあるときに使う。
pub fn split(source: &mut zip::Reader, open: &[u8], close: &[u8], keep: usize) -> Result<Split, Error> {
    let mut result = Split {head: Vec::new(), tail: Vec::new(), last: Vec::new(), found: false};
    let mut step = Step::Head;
    let mut carry: Vec<u8> = Vec::new();

    while let Some(piece) = source.next()? {
        let mut region = std::mem::take(&mut carry);
        region.extend_from_slice(&piece);
        let mut cursor = 0;

        loop {
            match step {
                Step::Head => match find(&region[cursor..], open) {
                    Some(found) => {
                        result.head.extend_from_slice(&region[cursor..cursor + found]);
                        cursor += found;
                        step = Step::Mark;
                    }

                    None => {
                        // 見つかりかけを次へ持ち越す
                        let hold = open.len() - 1;
                        let stop = region.len().saturating_sub(hold).max(cursor);
                        result.head.extend_from_slice(&region[cursor..stop]);
                        cursor = stop;
                        break;
                    }
                },

                // `<印 ...>` の終わりを見て、その場で閉じているかを決める
                Step::Mark => match find(&region[cursor..], b">") {
                    Some(found) => {
                        let stop = cursor + found;
                        let empty = region[stop - 1] == b'/';
                        cursor = stop + 1;
                        result.found = true;
                        step = if empty {Step::Tail} else {Step::Body};
                    }

                    None => break,
                },

                Step::Body => match find(&region[cursor..], close) {
                    Some(found) => {
                        hold_last(&mut result.last, &region[cursor..cursor + found], keep);
                        cursor += found + close.len();
                        step = Step::Tail;
                    }

                    None => {
                        let hold = close.len() - 1;
                        let stop = region.len().saturating_sub(hold).max(cursor);
                        hold_last(&mut result.last, &region[cursor..stop], keep);
                        cursor = stop;
                        break;
                    }
                },

                Step::Tail => {
                    result.tail.extend_from_slice(&region[cursor..]);
                    cursor = region.len();
                    break;
                }
            }
        }

        carry = region[cursor..].to_vec();
    }

    match step {
        Step::Tail => result.tail.extend_from_slice(&carry),
        Step::Head | Step::Mark => result.head.extend_from_slice(&carry),
        Step::Body => hold_last(&mut result.last, &carry, keep),
    }

    Ok(result)
}


/// split がいまどこを読んでいるか
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum Step {
    /// 開く印より前
    Head,
    /// 開く印の属性のところ
    Mark,
    /// 印の中
    Body,
    /// 閉じる印より後ろ
    Tail,
}


/// 末尾に近い keep バイトだけを残す
fn hold_last(buffer: &mut Vec<u8>, piece: &[u8], keep: usize) {
    if keep == 0 {
        return;
    }

    buffer.extend_from_slice(piece);

    if buffer.len() > keep * 2 {
        let start = buffer.len() - keep;
        buffer.copy_within(start.., 0);
        buffer.truncate(keep);
    }
}


/// 並びが出るところを探す
pub fn find(region: &[u8], pattern: &[u8]) -> Option<usize> {
    if pattern.len() > region.len() {
        return None;
    }

    (0..=region.len() - pattern.len()).find(|start| &region[*start..*start + pattern.len()] == pattern)
}


/// 並びが最後に出るところを探す
pub fn rfind(region: &[u8], pattern: &[u8]) -> Option<usize> {
    if pattern.len() > region.len() {
        return None;
    }

    (0..=region.len() - pattern.len())
        .rev()
        .find(|start| &region[*start..*start + pattern.len()] == pattern)
}