app.py

import os
import re
import shutil
import glob
import time
import datetime
import json
from flask import Flask, render_template, jsonify, request, send_file, Response
from ruamel.yaml import YAML
from io import StringIO
from werkzeug.utils import secure_filename

app = Flask(__name__)

SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
MATCH_DIR = os.path.join(SCRIPT_DIR, ".espanso", "match")
INACTIVE_DIR = os.path.join(MATCH_DIR, "inactive")
BACKUP_DIR = os.path.join(SCRIPT_DIR, ".espanso", "backups")

os.makedirs(MATCH_DIR, exist_ok=True)
os.makedirs(INACTIVE_DIR, exist_ok=True)
os.makedirs(BACKUP_DIR, exist_ok=True)

yaml = YAML()
yaml.preserve_quotes = True
yaml.width = 4096
yaml.default_flow_style = False


def find_match_files():
    files = sorted(glob.glob(os.path.join(MATCH_DIR, "*.yml")))
    return [f for f in files if "packages" not in f.lower()]


def find_inactive_files():
    files = sorted(glob.glob(os.path.join(INACTIVE_DIR, "*.yml")))
    return files


def load_all_matches():
    result = []
    for filepath in find_match_files():
        filename = os.path.basename(filepath)
        try:
            with open(filepath, "r", encoding="utf-8") as f:
                raw = f.read()

            labels = {}
            lines = raw.split("\n")
            match_idx = 0
            for line in lines:
                stripped = line.strip()
                m = re.match(r"^#\s*label:\s*(.+)$", stripped)
                if m:
                    labels[match_idx] = m.group(1).strip()
                elif stripped.startswith("- trigger:") or (stripped.startswith("- ") and "trigger" in stripped):
                    match_idx += 1

            with open(filepath, "r", encoding="utf-8") as f:
                data = yaml.load(f)

            if data and "matches" in data:
                for i, match in enumerate(data["matches"]):
                    if isinstance(match, dict) and "trigger" in match:
                        replace_val = match.get("replace", "")
                        result.append({
                            "file": filename,
                            "index": i,
                            "label": labels.get(i, ""),
                            "trigger": match.get("trigger", ""),
                            "replace": replace_val if replace_val else "",
                            "replace_type": "multiline" if (isinstance(replace_val, str) and "\n" in replace_val) else "single",
                            "vars": match.get("vars", None),
                            "has_vars": bool(match.get("vars")),
                        })
        except Exception as e:
            print(f"Error loading {filepath}: {e}")
    return result


def backup_file(filepath):
    if not os.path.exists(filepath):
        return
    for attempt in range(3):
        try:
            ts = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
            basename = os.path.basename(filepath)
            backup_path = os.path.join(BACKUP_DIR, f"{basename}.{ts}.bak")
            shutil.copy2(filepath, backup_path)
            latest = os.path.join(BACKUP_DIR, f"{basename}.latest.bak")
            shutil.copy2(filepath, latest)
            return
        except PermissionError:
            time.sleep(0.5)
    print(f"Warning: Could not backup {filepath}")


def write_yaml_with_labels(filepath, matches_data):
    backup_file(filepath)

    try:
        with open(filepath, "r", encoding="utf-8") as f:
            header_lines = []
            for line in f:
                if line.strip().startswith("matches:"):
                    break
                header_lines.append(line.rstrip("\n"))
    except FileNotFoundError:
        header_lines = []

    doc = {"matches": []}
    for m in matches_data:
        entry = {"trigger": m["trigger"], "replace": m["replace"]}
        if m.get("vars"):
            entry["vars"] = m["vars"]
        entry["word"] = True
        doc["matches"].append(entry)

    stream = StringIO()
    yaml.dump(doc, stream)
    content = stream.getvalue()

    y2 = YAML()
    y2.preserve_quotes = True
    y2.width = 4096
    parsed = y2.load(StringIO(content))
    if not parsed or "matches" not in parsed:
        return jsonify({"error": "YAML validation failed"}), 500

    lines = content.split("\n")
    new_lines = []
    match_idx = 0
    for line in lines:
        stripped = line.strip()
        if stripped.startswith("- trigger:"):
            label = matches_data[match_idx].get("label", "").strip() if match_idx < len(matches_data) else ""
            if label:
                indent = line[:len(line) - len(stripped)]
                new_lines.append(f"{indent}# label: {label}")
            match_idx += 1
        new_lines.append(line)

    final_lines = header_lines + [""] + new_lines
    final_content = "\n".join(final_lines)

    tmp_path = filepath + ".tmp"
    for attempt in range(3):
        try:
            with open(tmp_path, "w", encoding="utf-8") as f:
                f.write(final_content)
            os.replace(tmp_path, filepath)
            return None
        except PermissionError:
            time.sleep(0.5)
            if os.path.exists(tmp_path):
                os.remove(tmp_path)
    return jsonify({"error": "Write error: file is locked"}), 500


@app.route("/")
def index():
    return render_template("index.html")


@app.route("/api/matches", methods=["GET"])
def get_matches():
    return jsonify(load_all_matches())


@app.route("/api/matches", methods=["POST"])
def create_match():
    data = request.json
    trigger = data.get("trigger", "").strip()
    replace = data.get("replace", "").strip()
    label = data.get("label", "").strip()
    filename = data.get("file", "base.yml")

    if not trigger or not replace:
        return jsonify({"error": "Trigger and Replace are required"}), 400

    if not trigger.startswith(":"):
        trigger = ":" + trigger

    filepath = os.path.join(MATCH_DIR, filename)
    if not os.path.exists(filepath):
        with open(filepath, "w", encoding="utf-8") as f:
            f.write("# espanso match file\n\nmatches:\n")

    all_matches = load_all_matches()
    file_matches = [m for m in all_matches if m["file"] == filename]
    file_matches.append({
        "file": filename,
        "index": len(file_matches),
        "label": label,
        "trigger": trigger,
        "replace": replace,
        "vars": None,
        "has_vars": False,
    })

    err = write_yaml_with_labels(filepath, file_matches)
    if err:
        return err

    return jsonify({"ok": True})


@app.route("/api/matches/<filename>/<int:index>", methods=["PUT"])
def update_match(filename, index):
    data = request.json
    trigger = data.get("trigger", "").strip()
    replace = data.get("replace", "").strip()
    label = data.get("label", "").strip()

    if not trigger or not replace:
        return jsonify({"error": "Trigger and Replace are required"}), 400

    if not trigger.startswith(":"):
        trigger = ":" + trigger

    filepath = os.path.join(MATCH_DIR, filename)
    if not os.path.exists(filepath):
        return jsonify({"error": "File not found"}), 404

    all_matches = load_all_matches()
    file_matches = [m for m in all_matches if m["file"] == filename]

    if index >= len(file_matches):
        return jsonify({"error": "Index out of range"}), 404

    file_matches[index]["trigger"] = trigger
    file_matches[index]["replace"] = replace
    file_matches[index]["label"] = label

    err = write_yaml_with_labels(filepath, file_matches)
    if err:
        return err

    return jsonify({"ok": True})


@app.route("/api/matches/<filename>/<int:index>", methods=["DELETE"])
def delete_match(filename, index):
    filepath = os.path.join(MATCH_DIR, filename)
    if not os.path.exists(filepath):
        return jsonify({"error": "File not found"}), 404

    all_matches = load_all_matches()
    file_matches = [m for m in all_matches if m["file"] == filename]

    if index >= len(file_matches):
        return jsonify({"error": "Index out of range"}), 404

    file_matches.pop(index)

    err = write_yaml_with_labels(filepath, file_matches)
    if err:
        return err

    return jsonify({"ok": True})


@app.route("/api/files", methods=["GET"])
def list_files():
    active = [os.path.basename(f) for f in find_match_files()]
    inactive = [os.path.basename(f) for f in find_inactive_files()]
    return jsonify({"active": active, "inactive": inactive})


@app.route("/api/files/move", methods=["POST"])
def move_file():
    data = request.json
    filename = data.get("filename")
    direction = data.get("direction")

    if not filename:
        return jsonify({"error": "No filename provided"}), 400

    src = ""
    dst = ""

    if direction == "to_inactive":
        src = os.path.join(MATCH_DIR, filename)
        dst = os.path.join(INACTIVE_DIR, filename)
    elif direction == "to_active":
        src = os.path.join(INACTIVE_DIR, filename)
        dst = os.path.join(MATCH_DIR, filename)
    else:
        return jsonify({"error": "Invalid direction"}), 400

    if not os.path.exists(src):
        return jsonify({"error": "File not found"}), 404

    backup_file(src)

    shutil.move(src, dst)
    return jsonify({"ok": True})


@app.route("/api/export/<filename>", methods=["GET"])
def export_file(filename):
    filepath = os.path.join(MATCH_DIR, filename)
    if not os.path.exists(filepath):
        filepath = os.path.join(INACTIVE_DIR, filename)
    if not os.path.exists(filepath):
        return jsonify({"error": "File not found"}), 404
    return send_file(filepath, as_attachment=True, download_name=filename)


@app.route("/api/import", methods=["POST"])
def import_file():
    if "file" not in request.files:
        return jsonify({"error": "No file provided"}), 400

    file = request.files["file"]
    mode = request.form.get("mode", "merge")

    if file.filename == "":
        return jsonify({"error": "No filename"}), 400

    filename = secure_filename(file.filename)
    if not filename.endswith(".yml"):
        filename += ".yml"

    content = file.read().decode("utf-8")

    try:
        y = YAML()
        data = y.load(StringIO(content))
        if not data or "matches" not in data:
            return jsonify({"error": "Invalid format: no matches section"}), 400
    except Exception as e:
        return jsonify({"error": f"YAML parse error: {e}"}), 400

    if mode == "replace":
        filepath = os.path.join(MATCH_DIR, "base.yml")
        backup_file(filepath)
        with open(filepath, "w", encoding="utf-8") as f:
            f.write(content)
        return jsonify({"ok": True, "mode": "replace"})

    if mode == "merge":
        target_path = os.path.join(MATCH_DIR, "base.yml")
        backup_file(target_path)

        try:
            with open(target_path, "r", encoding="utf-8") as f:
                existing = yaml.load(f)
            if existing is None:
                existing = {"matches": []}
        except Exception:
            existing = {"matches": []}

        if "matches" not in existing:
            existing["matches"] = []

        existing["matches"].extend(data["matches"])

        err = write_yaml_with_labels(target_path, [
            {
                "trigger": m.get("trigger", ""),
                "replace": m.get("replace", ""),
                "vars": m.get("vars"),
                "label": ""
            } for m in data["matches"]
        ])
        if err:
            return err

        return jsonify({"ok": True, "mode": "merge", "added": len(data["matches"])})

    return jsonify({"error": "Unknown mode"}), 400


@app.route("/api/backups", methods=["GET"])
def list_backups():
    backups = []
    if os.path.exists(BACKUP_DIR):
        for f in sorted(os.listdir(BACKUP_DIR), reverse=True):
            if f.endswith(".bak"):
                fp = os.path.join(BACKUP_DIR, f)
                backups.append({
                    "name": f,
                    "size": os.path.getsize(fp),
                    "time": datetime.datetime.fromtimestamp(os.path.getmtime(fp)).strftime("%Y-%m-%d %H:%M:%S"),
                })
    return jsonify(backups)


@app.route("/api/backups/<name>/restore", methods=["POST"])
def restore_backup(name):
    backup_path = os.path.join(BACKUP_DIR, name)
    if not os.path.exists(backup_path):
        return jsonify({"error": "Backup not found"}), 404

    target_name = name.split(".")[0] + ".yml"
    target_path = os.path.join(MATCH_DIR, target_name)

    backup_file(target_path)
    shutil.copy2(backup_path, target_path)
    return jsonify({"ok": True})


if __name__ == "__main__":
    print(f"Espanso Manager running at: http://localhost:5567")
    print(f"Match dir: {MATCH_DIR}")
    app.run(host="127.0.0.1", port=5567, debug=False)