import os
import re

from flask import Flask, redirect, render_template, request, url_for
from flask_sqlalchemy import SQLAlchemy


BASE_DIR = os.path.dirname(os.path.abspath(__file__))
DB_DIR = os.path.join(BASE_DIR, "data")
os.makedirs(DB_DIR, exist_ok=True)
DB_PATH = os.path.join(DB_DIR, "inventory.db")

app = Flask(__name__)
app.config["SQLALCHEMY_DATABASE_URI"] = f"sqlite:///{DB_PATH}"
app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = False
db = SQLAlchemy(app)

LOW_STOCK_THRESHOLD = 5


BOX_TYPES = {
    "small_28": {
        "label": "28格小盒大盒",
        "default_capacity": 28,
        "default_desc": "4连排小盒，常见摆放为竖向7排",
        "default_prefix": "A",
    },
    "medium_14": {
        "label": "14格中盒大盒",
        "default_capacity": 14,
        "default_desc": "14格中盒，内部摆放方向与28格不同",
        "default_prefix": "B",
    },
    "bag": {
        "label": "袋装清单",
        "default_capacity": 1,
        "default_desc": "用于较小防静电袋存放",
        "default_prefix": "BAG",
    },
}


class Box(db.Model):
    __tablename__ = "boxes"

    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(100), nullable=False, unique=True)
    description = db.Column(db.String(255), nullable=True)
    box_type = db.Column(db.String(30), nullable=False, default="small_28")
    slot_capacity = db.Column(db.Integer, nullable=False, default=28)
    slot_prefix = db.Column(db.String(16), nullable=False, default="A")
    start_number = db.Column(db.Integer, nullable=False, default=1)


class Component(db.Model):
    __tablename__ = "components"

    id = db.Column(db.Integer, primary_key=True)
    box_id = db.Column(db.Integer, db.ForeignKey("boxes.id"), nullable=False)
    slot_index = db.Column(db.Integer, nullable=False)

    part_no = db.Column(db.String(100), nullable=False)
    name = db.Column(db.String(120), nullable=False)
    specification = db.Column(db.String(120), nullable=True)
    quantity = db.Column(db.Integer, nullable=False, default=0)
    location = db.Column(db.String(120), nullable=True)
    note = db.Column(db.Text, nullable=True)
    is_enabled = db.Column(db.Boolean, nullable=False, default=True)

    box = db.relationship("Box", backref=db.backref("components", lazy=True))

    __table_args__ = (
        db.UniqueConstraint("box_id", "slot_index", name="uq_box_slot"),
    )


def _add_column_if_missing(table_name: str, column_name: str, ddl: str) -> None:
    columns = {
        row[1]
        for row in db.session.execute(db.text(f"PRAGMA table_info({table_name})")).fetchall()
    }
    if column_name not in columns:
        db.session.execute(db.text(f"ALTER TABLE {table_name} ADD COLUMN {ddl}"))


def ensure_schema() -> None:
    _add_column_if_missing(
        "boxes",
        "box_type",
        "box_type VARCHAR(30) NOT NULL DEFAULT 'small_28'",
    )
    _add_column_if_missing(
        "boxes",
        "slot_capacity",
        "slot_capacity INTEGER NOT NULL DEFAULT 28",
    )
    _add_column_if_missing(
        "boxes",
        "slot_prefix",
        "slot_prefix VARCHAR(16) NOT NULL DEFAULT 'A'",
    )
    _add_column_if_missing(
        "boxes",
        "start_number",
        "start_number INTEGER NOT NULL DEFAULT 1",
    )
    _add_column_if_missing(
        "components",
        "is_enabled",
        "is_enabled BOOLEAN NOT NULL DEFAULT 1",
    )
    db.session.commit()


def slot_code_for_box(box: Box, slot_index: int) -> str:
    serial = box.start_number + slot_index - 1
    return f"{box.slot_prefix}{serial}"


def slot_range_label(box: Box) -> str:
    start_code = slot_code_for_box(box, 1)
    end_code = slot_code_for_box(box, box.slot_capacity)
    return f"{start_code}-{end_code}"


def compose_box_name(base_name: str, prefix: str, start_number: int, slot_capacity: int) -> str:
    base = (base_name or "").strip()
    if not base:
        base = "盒子"
    end_number = start_number + slot_capacity - 1
    return f"{base} {prefix}{start_number}-{prefix}{end_number}"


def make_unique_box_name(candidate_name: str, exclude_box_id: int = None) -> str:
    name = candidate_name
    counter = 2
    while True:
        query = Box.query.filter_by(name=name)
        if exclude_box_id is not None:
            query = query.filter(Box.id != exclude_box_id)
        if not query.first():
            return name
        name = f"{candidate_name} #{counter}"
        counter += 1


def infer_base_name(box: Box) -> str:
    pattern = rf"\s+{re.escape(box.slot_prefix)}\d+-{re.escape(box.slot_prefix)}\d+(?:\s+#\d+)?$"
    base = re.sub(pattern, "", box.name).strip()
    return base or box.name


def slot_data_for_box(box: Box):
    components = Component.query.filter_by(box_id=box.id).all()
    slot_map = {c.slot_index: c for c in components}
    slots = []
    for slot in range(1, box.slot_capacity + 1):
        slots.append(
            {
                "slot": slot,
                "slot_code": slot_code_for_box(box, slot),
                "component": slot_map.get(slot),
            }
        )
    return slots


def bag_rows_for_box(box: Box):
    rows = []
    components = (
        Component.query.filter_by(box_id=box.id)
        .order_by(Component.slot_index.asc())
        .all()
    )
    for c in components:
        rows.append({"component": c, "slot_code": slot_code_for_box(box, c.slot_index)})
    return rows


def _parse_non_negative_int(raw_value: str, default_value: int = 0) -> int:
    raw = (raw_value or "").strip()
    if raw == "":
        return default_value
    value = int(raw)
    if value < 0:
        raise ValueError
    return value


def normalize_legacy_data() -> None:
    db.session.execute(
        db.text(
            "UPDATE boxes SET box_type = 'small_28' WHERE box_type IS NULL OR box_type = ''"
        )
    )
    db.session.execute(
        db.text("UPDATE boxes SET slot_capacity = 28 WHERE slot_capacity IS NULL")
    )
    db.session.execute(
        db.text("UPDATE boxes SET slot_prefix = 'A' WHERE slot_prefix IS NULL OR slot_prefix = ''")
    )
    db.session.execute(
        db.text("UPDATE boxes SET start_number = 1 WHERE start_number IS NULL")
    )
    db.session.execute(
        db.text("UPDATE components SET is_enabled = 1 WHERE is_enabled IS NULL")
    )

    for box in Box.query.all():
        if box.box_type not in BOX_TYPES:
            box.box_type = "small_28"
        if not box.slot_capacity or box.slot_capacity < 1:
            box.slot_capacity = BOX_TYPES[box.box_type]["default_capacity"]
        if not box.slot_prefix:
            box.slot_prefix = BOX_TYPES[box.box_type]["default_prefix"]
        if box.start_number is None or box.start_number < 0:
            box.start_number = 1

    db.session.commit()


def make_overview_rows(box: Box):
    enabled_components = (
        Component.query.filter_by(box_id=box.id, is_enabled=True)
        .order_by(Component.slot_index.asc())
        .all()
    )
    rows = []
    for c in enabled_components:
        rows.append(
            {
                "slot_code": slot_code_for_box(box, c.slot_index),
                "name": c.name,
                "part_no": c.part_no,
            }
        )
    return rows


def box_sort_key(box: Box):
    return (
        (box.slot_prefix or "").upper(),
        box.start_number if box.start_number is not None else 0,
        box.name or "",
    )


def has_range_conflict(
    *,
    box_type: str,
    prefix: str,
    start_number: int,
    slot_capacity: int,
    exclude_box_id: int = None,
):
    end_number = start_number + slot_capacity - 1
    query = Box.query.filter_by(box_type=box_type, slot_prefix=prefix)
    if exclude_box_id is not None:
        query = query.filter(Box.id != exclude_box_id)

    for other in query.all():
        other_start = other.start_number
        other_end = other.start_number + other.slot_capacity - 1
        # Two ranges overlap unless one is strictly before the other.
        if not (end_number < other_start or start_number > other_end):
            return True, other

    return False, None


def suggest_next_start_number(
    *,
    box_type: str,
    prefix: str,
    slot_capacity: int,
    exclude_box_id: int = None,
) -> int:
    max_end = 0
    query = Box.query.filter_by(box_type=box_type, slot_prefix=prefix)
    if exclude_box_id is not None:
        query = query.filter(Box.id != exclude_box_id)

    for other in query.all():
        other_end = other.start_number + other.slot_capacity - 1
        if other_end > max_end:
            max_end = other_end

    return max_end + 1 if max_end > 0 else 1


def build_index_anchor(box_type: str = "") -> str:
    if box_type in BOX_TYPES:
        return f"group-{box_type}"
    return ""


def bad_request(message: str, box_type: str = ""):
    anchor = build_index_anchor(box_type)
    if anchor:
        back_url = f"{url_for('index')}#{anchor}"
    else:
        back_url = request.referrer or url_for("index")

    return (
        render_template(
            "error.html",
            status_code=400,
            title="请求参数有误",
            message=message,
            back_url=back_url,
        ),
        400,
    )


def render_box_page(box: Box, error: str = "", notice: str = ""):
    slots = slot_data_for_box(box)
    bag_rows = bag_rows_for_box(box) if box.box_type == "bag" else []
    return render_template(
        "box.html",
        box=box,
        slots=slots,
        bag_rows=bag_rows,
        box_types=BOX_TYPES,
        slot_range=slot_range_label(box),
        low_stock_threshold=LOW_STOCK_THRESHOLD,
        error=error,
        notice=notice,
    )


@app.route("/")
def index():
    boxes = Box.query.all()
    boxes.sort(key=box_sort_key)
    groups = {key: [] for key in BOX_TYPES.keys()}

    for box in boxes:
        box_type = box.box_type if box.box_type in BOX_TYPES else "small_28"
        overview_rows = make_overview_rows(box)
        groups[box_type].append(
            {
                "box": box,
                "used_count": len(overview_rows),
                "slot_range": slot_range_label(box),
                "overview_rows": overview_rows,
                "base_name": infer_base_name(box),
            }
        )

    return render_template("index.html", groups=groups, box_types=BOX_TYPES)


@app.route("/boxes/create", methods=["POST"])
def create_box():
    box_type = request.form.get("box_type", "small_28").strip()
    base_name = request.form.get("name", "").strip()
    description = request.form.get("description", "").strip()
    slot_prefix = request.form.get("slot_prefix", "").strip().upper()

    if box_type not in BOX_TYPES:
        return bad_request("无效盒子类型", box_type)
    if not base_name:
        return bad_request("盒子名称不能为空", box_type)

    try:
        start_number = _parse_non_negative_int(request.form.get("start_number", "1"), 1)
    except ValueError:
        return bad_request("起始序号必须是大于等于 0 的整数", box_type)

    meta = BOX_TYPES[box_type]
    effective_prefix = slot_prefix or meta["default_prefix"]
    conflict, other_box = has_range_conflict(
        box_type=box_type,
        prefix=effective_prefix,
        start_number=start_number,
        slot_capacity=meta["default_capacity"],
    )
    if conflict:
        return bad_request(
            "编号范围冲突: 与现有盒子 "
            f"[{other_box.name}]"
            " 重叠，请更换前缀或起始序号",
            box_type,
        )

    generated_name = compose_box_name(
        base_name=base_name,
        prefix=effective_prefix,
        start_number=start_number,
        slot_capacity=meta["default_capacity"],
    )
    final_name = make_unique_box_name(generated_name)

    box = Box(
        name=final_name,
        description=description or meta["default_desc"],
        box_type=box_type,
        slot_capacity=meta["default_capacity"],
        slot_prefix=effective_prefix,
        start_number=start_number,
    )
    db.session.add(box)
    db.session.commit()
    return redirect(url_for("index"))


@app.route("/boxes/<int:box_id>/update", methods=["POST"])
def update_box(box_id: int):
    box = Box.query.get_or_404(box_id)

    base_name = request.form.get("name", "").strip()
    description = request.form.get("description", "").strip()
    slot_prefix = request.form.get("slot_prefix", "").strip().upper()

    if not base_name:
        return bad_request("盒子名称不能为空", box.box_type)

    try:
        start_number = _parse_non_negative_int(request.form.get("start_number", "1"), 1)
    except ValueError:
        return bad_request("起始序号必须是大于等于 0 的整数", box.box_type)

    effective_prefix = slot_prefix or BOX_TYPES[box.box_type]["default_prefix"]
    conflict, other_box = has_range_conflict(
        box_type=box.box_type,
        prefix=effective_prefix,
        start_number=start_number,
        slot_capacity=box.slot_capacity,
        exclude_box_id=box.id,
    )
    if conflict:
        return bad_request(
            "编号范围冲突: 与现有盒子 "
            f"[{other_box.name}]"
            " 重叠，请更换前缀或起始序号",
            box.box_type,
        )

    generated_name = compose_box_name(
        base_name=base_name,
        prefix=effective_prefix,
        start_number=start_number,
        slot_capacity=box.slot_capacity,
    )

    box.name = make_unique_box_name(generated_name, exclude_box_id=box.id)
    box.description = description or BOX_TYPES[box.box_type]["default_desc"]
    box.slot_prefix = effective_prefix
    box.start_number = start_number
    db.session.commit()
    return redirect(url_for("index"))


@app.route("/boxes/<int:box_id>/delete", methods=["POST"])
def delete_box(box_id: int):
    box = Box.query.get_or_404(box_id)
    Component.query.filter_by(box_id=box.id).delete()
    db.session.delete(box)
    db.session.commit()
    return redirect(url_for("index"))


@app.route("/boxes/suggest-start")
def suggest_start():
    box_type = request.args.get("box_type", "small_28").strip()
    if box_type not in BOX_TYPES:
        return {"ok": False, "message": "无效盒子类型"}, 400

    slot_prefix = request.args.get("slot_prefix", "").strip().upper()
    effective_prefix = slot_prefix or BOX_TYPES[box_type]["default_prefix"]

    box_id_raw = request.args.get("box_id", "").strip()
    exclude_box_id = None
    slot_capacity = BOX_TYPES[box_type]["default_capacity"]

    if box_id_raw:
        try:
            box_id = int(box_id_raw)
        except ValueError:
            return {"ok": False, "message": "box_id 非法"}, 400

        box = Box.query.get(box_id)
        if not box:
            return {"ok": False, "message": "盒子不存在"}, 404

        box_type = box.box_type
        slot_capacity = box.slot_capacity
        exclude_box_id = box.id

    suggested = suggest_next_start_number(
        box_type=box_type,
        prefix=effective_prefix,
        slot_capacity=slot_capacity,
        exclude_box_id=exclude_box_id,
    )
    end_number = suggested + slot_capacity - 1

    return {
        "ok": True,
        "start_number": suggested,
        "slot_prefix": effective_prefix,
        "preview_range": f"{effective_prefix}{suggested}-{effective_prefix}{end_number}",
    }


@app.route("/box/<int:box_id>")
def view_box(box_id: int):
    box = Box.query.get_or_404(box_id)
    return render_box_page(box)


@app.route("/box/<int:box_id>/bags/add", methods=["POST"])
def add_bag_item(box_id: int):
    box = Box.query.get_or_404(box_id)
    if box.box_type != "bag":
        return "当前盒子不是袋装清单", 400

    part_no = request.form.get("part_no", "").strip()
    name = request.form.get("name", "").strip()
    specification = request.form.get("specification", "").strip()
    location = request.form.get("location", "").strip()
    note = request.form.get("note", "").strip()

    if not part_no or not name:
        return render_box_page(box, error="袋装新增失败: 料号和名称不能为空")

    try:
        quantity = _parse_non_negative_int(request.form.get("quantity", "0"), 0)
    except ValueError:
        return render_box_page(box, error="袋装新增失败: 数量必须是大于等于 0 的整数")

    next_slot = (
        db.session.query(db.func.max(Component.slot_index))
        .filter(Component.box_id == box.id)
        .scalar()
        or 0
    ) + 1

    item = Component(
        box_id=box.id,
        slot_index=next_slot,
        part_no=part_no,
        name=name,
        quantity=quantity,
        specification=specification or None,
        location=location or None,
        note=note or None,
        is_enabled=True,
    )
    db.session.add(item)

    if next_slot > box.slot_capacity:
        box.slot_capacity = next_slot

    db.session.commit()
    return render_box_page(box, notice="已新增 1 条袋装记录")


@app.route("/box/<int:box_id>/bags/batch", methods=["POST"])
def add_bag_items_batch(box_id: int):
    box = Box.query.get_or_404(box_id)
    if box.box_type != "bag":
        return "当前盒子不是袋装清单", 400

    raw_lines = request.form.get("lines", "")
    lines = [line.strip() for line in raw_lines.splitlines() if line.strip()]
    if not lines:
        return render_box_page(box, error="批量新增失败: 请至少输入一行")

    invalid_lines = []
    added_count = 0
    next_slot = (
        db.session.query(db.func.max(Component.slot_index))
        .filter(Component.box_id == box.id)
        .scalar()
        or 0
    ) + 1

    for line_no, line in enumerate(lines, start=1):
        parts = [p.strip() for p in re.split(r"[,\t]", line)]
        while len(parts) < 6:
            parts.append("")

        part_no = parts[0]
        name = parts[1]
        quantity_raw = parts[2]
        specification = parts[3]
        location = parts[4]
        note = parts[5]

        if not part_no or not name:
            invalid_lines.append(f"第 {line_no} 行")
            continue

        try:
            quantity = _parse_non_negative_int(quantity_raw, 0)
        except ValueError:
            invalid_lines.append(f"第 {line_no} 行")
            continue

        db.session.add(
            Component(
                box_id=box.id,
                slot_index=next_slot,
                part_no=part_no,
                name=name,
                quantity=quantity,
                specification=specification or None,
                location=location or None,
                note=note or None,
                is_enabled=True,
            )
        )
        added_count += 1
        next_slot += 1

    if added_count:
        box.slot_capacity = max(box.slot_capacity, next_slot - 1)
        db.session.commit()

    if invalid_lines and added_count == 0:
        return render_box_page(
            box,
            error="批量新增失败: 数据格式不正确（请检查: " + ", ".join(invalid_lines) + "）",
        )

    if invalid_lines:
        return render_box_page(
            box,
            notice=f"已新增 {added_count} 条，以下行被跳过: " + ", ".join(invalid_lines),
        )

    return render_box_page(box, notice=f"批量新增成功，共 {added_count} 条")


@app.route("/edit/<int:box_id>/<int:slot>", methods=["GET", "POST"])
def edit_component(box_id: int, slot: int):
    box = Box.query.get_or_404(box_id)
    if slot < 1 or slot > box.slot_capacity:
        return "无效的格子编号", 400

    component = Component.query.filter_by(box_id=box.id, slot_index=slot).first()

    if request.method == "POST":
        action = request.form.get("action", "save")

        if action == "delete":
            if component:
                db.session.delete(component)
                db.session.commit()
            return redirect(url_for("view_box", box_id=box.id))

        if action == "toggle_enable":
            if component:
                component.is_enabled = True
                db.session.commit()
            return redirect(url_for("edit_component", box_id=box.id, slot=slot))

        if action == "toggle_disable":
            if component:
                component.is_enabled = False
                db.session.commit()
            return redirect(url_for("edit_component", box_id=box.id, slot=slot))

        part_no = request.form.get("part_no", "").strip()
        name = request.form.get("name", "").strip()
        specification = request.form.get("specification", "").strip()
        quantity_raw = request.form.get("quantity", "0").strip()
        location = request.form.get("location", "").strip()
        note = request.form.get("note", "").strip()
        is_enabled = request.form.get("is_enabled") == "1"

        if not part_no or not name:
            error = "料号和名称不能为空"
            return render_template(
                "edit.html",
                box=box,
                slot=slot,
                slot_code=slot_code_for_box(box, slot),
                component=component,
                error=error,
            )

        try:
            quantity = _parse_non_negative_int(quantity_raw, 0)
        except ValueError:
            error = "数量必须是大于等于 0 的整数"
            return render_template(
                "edit.html",
                box=box,
                slot=slot,
                slot_code=slot_code_for_box(box, slot),
                component=component,
                error=error,
            )

        if component is None:
            component = Component(box_id=box.id, slot_index=slot)
            db.session.add(component)

        component.part_no = part_no
        component.name = name
        component.specification = specification or None
        component.quantity = quantity
        component.location = location or None
        component.note = note or None
        component.is_enabled = is_enabled

        db.session.commit()
        return redirect(url_for("view_box", box_id=box.id))

    return render_template(
        "edit.html",
        box=box,
        slot=slot,
        slot_code=slot_code_for_box(box, slot),
        component=component,
    )


@app.route("/scan")
def scan_page():
    keyword = request.args.get("q", "").strip()
    results = []

    if keyword:
        raw_results = (
            Component.query.join(Box, Box.id == Component.box_id)
            .filter(
                db.or_(
                    Component.part_no.ilike(f"%{keyword}%"),
                    Component.name.ilike(f"%{keyword}%"),
                )
            )
            .order_by(Component.part_no.asc())
            .all()
        )

        for c in raw_results:
            box = Box.query.get(c.box_id)
            results.append(
                {
                    "component": c,
                    "box_name": box.name if box else f"盒 {c.box_id}",
                    "slot_code": slot_code_for_box(box, c.slot_index) if box else str(c.slot_index),
                }
            )

    return render_template("scan.html", keyword=keyword, results=results)


@app.route("/api/scan")
def scan_api():
    code = request.args.get("code", "").strip()
    if not code:
        return {"ok": False, "message": "code 不能为空"}, 400

    item = Component.query.filter_by(part_no=code).first()
    if not item:
        return {"ok": False, "message": "未找到元件"}, 404

    box = Box.query.get(item.box_id)
    return {
        "ok": True,
        "data": {
            "id": item.id,
            "part_no": item.part_no,
            "name": item.name,
            "quantity": item.quantity,
            "box_id": item.box_id,
            "box_name": box.name if box else None,
            "slot_index": item.slot_index,
            "slot_code": slot_code_for_box(box, item.slot_index) if box else str(item.slot_index),
            "is_enabled": bool(item.is_enabled),
        },
    }


def bootstrap() -> None:
    with app.app_context():
        db.create_all()
        ensure_schema()
        normalize_legacy_data()


bootstrap()


if __name__ == "__main__":
    app.run(host="0.0.0.0", port=5000, debug=True)