# backend/storage.py
import os
import json
import time
import datetime
import pcbnew

class StorageManager:
    def __init__(self):
        self.project_dir = ""
        self.session_dir = ""
        self.layers_dir = ""
        self.master_file = ""

    def _get_board_path(self):
        try:
            board = pcbnew.GetBoard()
            return board.GetFileName()
        except:
            return ""

    def setup_paths(self):
        board_path = self._get_board_path()
        if not board_path: return False

        self.project_dir = os.path.dirname(board_path)
        filename = os.path.basename(board_path)
        schematic_name = os.path.splitext(filename)[0]
        
        try:
            mtime = os.path.getmtime(board_path)
            ts_str = str(int(mtime))
        except:
            ts_str = str(int(time.time()))

        date_str = datetime.datetime.fromtimestamp(mtime).strftime("%b_%d")

        session_name = f"{schematic_name}_{ts_str}_{date_str}"
        self.session_dir = os.path.join(self.project_dir, session_name)
        self.layers_dir = os.path.join(self.session_dir, "logical_layers")
        self.master_file = os.path.join(self.layers_dir, "$Master$.json")

        if not os.path.exists(self.layers_dir):
            try:
                os.makedirs(self.layers_dir)
            except OSError as e:
                print(f"Storage: Failed to create dirs: {e}")
                return False
        
        return True

    def save_item(self, item_data, uuid=None):
        if not self.session_dir: self.setup_paths()
        
        cls = item_data.get('class', 'Item')
        ref = item_data.get('ref', '')
        net = item_data.get('net', '')
        
        name_part = ref if ref else (net if net else cls)
        name_part = "".join(c for c in name_part if c.isalnum() or c in ('_', '-'))
        
        suffix = uuid[:8] if uuid else "unknown"
        filename = f"{name_part}_{suffix}.json"
        
        filepath = os.path.join(self.session_dir, filename)
        
        try:
            with open(filepath, 'w') as f:
                json.dump(item_data, f, indent=2)
            return filename
        except Exception as e:
            print(f"Storage: Error saving item {filename}: {e}")
            return None

    def save_layer(self, layer_name, layer_data):
        if not self.session_dir: self.setup_paths()
        
        filename = f"{layer_name}.json"
        filepath = os.path.join(self.layers_dir, filename)
        
        try:
            with open(filepath, 'w') as f:
                json.dump(layer_data, f, indent=2)
            return filename
        except Exception as e:
            print(f"Storage: Error saving layer {layer_name}: {e}")
            return None

    def update_master(self, layers_list):
        if not self.session_dir: self.setup_paths()
        
        master_data = {
            "updated": time.time(),
            "layers": []
        }
        
        for l in layers_list:
            master_data["layers"].append({
                "name": l.name,
                "visible": l.visible,
                "item_count": len(l.on_board_items) if l.visible else len(l.stored_items),
                "file": f"{l.name}.json"
            })
            
        try:
            with open(self.master_file, 'w') as f:
                json.dump(master_data, f, indent=2)
        except Exception as e:
            print(f"Storage: Error updating Master: {e}")

    def load_master(self):
        if not self.session_dir: self.setup_paths()
        if os.path.exists(self.master_file):
            try:
                with open(self.master_file, 'r') as f:
                    return json.load(f)
            except: pass
        return None

    def load_layer(self, layer_name):
        if not self.session_dir: self.setup_paths()
        filepath = os.path.join(self.layers_dir, f"{layer_name}.json")
        if os.path.exists(filepath):
            with open(filepath, 'r') as f:
                return json.load(f)
        return None

    def load_item(self, filename):
        if not self.session_dir: self.setup_paths()
        filepath = os.path.join(self.session_dir, filename)
        if os.path.exists(filepath):
            with open(filepath, 'r') as f:
                return json.load(f)
        return None