#!/usr/bin/env python3
# -*- coding: utf-8 -*-

"""
Первый проход КВС (однопроходная версия с заглушками)
Генерирует CSV-таблицу напрямую из AST
- Неизвестные метки заменяются заглушками (0xCC) с пометкой в колонке 'уводящий_адрес'
- В колонке 'приводящая_метка' записываются имена меток, находящихся по данному адресу (через запятую)
- Колонка 'команда_со_значениями' оставлена пустой (для второго прохода)
- Колонки 'рассчитанный_уводящий_адрес' и 'рассчитанный_байт' оставлены для второго прохода
- Колонка 'виртуальный_адрес' содержит виртуальный адрес байта (для pass4)
"""

import sys
import csv
import struct

sys.path.insert(0, '.')
from kvs_data import (
    PAGE_SIZE, text_vaddr_base, align_up,
    ALWAYS_STUB_INSTRUCTIONS
)
from kvs_encoder import encode_instruction

# ========== ГЛОБАЛЬНОЕ СОСТОЯНИЕ ==========
entries = []
current_address = 0
current_segment = '.header'
last_segment = None

vaddr_text = text_vaddr_base
vaddr_data = None
vaddr_bnd = None
data_offset = 0x2000

text_buffer = bytearray()
data_buffer = bytearray()
bss_size = 0

labels = {}
label_sections = {}
symbols = {}

pending_labels = []

text_pos = 0
data_pos = 0

entry_point = "_start"
relocations = []


def reset_state():
    global entries, current_address, current_segment, last_segment
    global text_buffer, data_buffer, bss_size
    global vaddr_data, vaddr_bnd
    global labels, label_sections, symbols, text_pos, data_pos, entry_point, relocations
    global pending_labels
    
    entries = []
    current_address = 0
    current_segment = '.header'
    last_segment = None
    text_buffer = bytearray()
    data_buffer = bytearray()
    bss_size = 0
    vaddr_data = None
    vaddr_bnd = None
    data_offset = 0x2000
    labels = {}
    label_sections = {}
    symbols = {}
    text_pos = 0
    data_pos = 0
    entry_point = "_start"
    relocations = []
    pending_labels = []


def set_segment(segment: str):
    global current_segment
    current_segment = segment


def get_virtual_address():
    """Возвращает виртуальный адрес для текущей позиции"""
    global data_offset
    
    if current_segment == '.text':
        return vaddr_text + (current_address - 0x1000)
    elif current_segment == '.data':
        if vaddr_data is None:
            return current_address
        return vaddr_data + (current_address - data_offset)
    else:
        return current_address


def add_byte(value: int, source: str = "", target=None, labels_list=None):
    global current_address, last_segment, pending_labels
    
    effective_labels = ""
    if labels_list is not None and labels_list:
        effective_labels = ','.join(labels_list)
    elif pending_labels:
        effective_labels = ','.join(pending_labels)
    
    show_segment = current_segment
    if show_segment:
        last_segment = current_segment
    
    virt_addr = get_virtual_address()
    byte_val = value & 0xFF
    
    entries.append((
        show_segment if show_segment else "",
        current_address,
        f"0x{virt_addr:08x}",
        f"0x{byte_val:02x}",
        target if target else "",
        source,
        effective_labels,
        "",
        "",
        f"0x{byte_val:02x}"
    ))
    current_address += 1
    
    if pending_labels:
        pending_labels = []

def add_bss_entry(size: int, label: str = None):
    global bss_size, vaddr_bnd
    
    bss_start = bss_size
    bss_size += size
    
    # Виртуальный адрес начала блока
    virt_addr = vaddr_bnd + bss_start
    
    entries.append((
        ".bss",                     # сегмент
        "BSS",                      # файловый адрес (специальное значение)
        f"0x{virt_addr:08x}",       # виртуальный адрес
        "",                         # байт
        "",                         # уводящий адрес
        f".резб {size}",            # исходная команда
        label if label else "",     # приводящая метка
        "", "", ""
    ))        
    """Добавляет запись для BSS в CSV """
"""
def add_bss_entry(size: int, label: str = None):

    global bss_size, vaddr_bnd
    
    bss_start = bss_size
    bss_size += size
    
    bss_file_addr = "BSS"
    bss_file_addr = current_address
    
    for offset in range(size):
        virt_addr = vaddr_bnd + bss_start + offset
        label_name = label if offset == 0 and label else ""
        
        # ПОРЯДОК ПОЛЕЙ ДОЛЖЕН СООТВЕТСТВОВАТЬ РАСПАКОВКЕ В save_to_csv:
        # segment, addr, virt_addr, byte_str, target, source, label, cmd_with_values, calc_target, calc_byte
        entries.append((
            ".bss",                                     # segment
            f"0x{bss_file_addr + offset:08x}",          # addr
            f"0x{virt_addr:08x}",                       # virt_addr
            "0x00",                                     # byte_str
            "",                                         # target (уводящий_адрес) - пусто
            f".резб {size}" if offset == 0 else "",     # source (исходная_команда)
            label_name,                                 # label (приводящая_метка) ← сюда имя метки!
            "",                                         # cmd_with_values
            "",                                         # calc_target
            "0x00"                                      # calc_byte
        ))
"""        


def add_bytes(values, source: str = "", target=None):
    for i, v in enumerate(values):
        add_byte(v, source if i == 0 else "", target if i == 0 else None)


def add_word16(value: int, source: str = "", target=None):
    add_bytes(struct.pack('<H', value & 0xFFFF), source, target)


def add_word32(value: int, source: str = "", target=None):
    add_bytes(struct.pack('<I', value & 0xFFFFFFFF), source, target)


def add_word64(value: int, source: str = "", target=None):
    add_bytes(struct.pack('<Q', value & 0xFFFFFFFFFFFFFFFF), source, target)


def add_dwords(values: list, source: str = "", target=None):
    for val in values:
        add_word32(val, source, target)


def add_qwords(values: list, source: str = "", target=None):
    for val in values:
        add_word64(val, source, target)


def align_to(alignment: int):
    global current_address, pending_labels
    padding = (alignment - (current_address % alignment)) % alignment
    if padding > 0:
        pending_labels = []
        current_address += padding


def unescape_string(s):
    result = []
    i = 0
    while i < len(s):
        if s[i] == '\\' and i + 1 < len(s):
            if s[i + 1] == 'n':
                result.append('\n')
            elif s[i + 1] == 't':
                result.append('\t')
            elif s[i + 1] == 'r':
                result.append('\r')
            else:
                result.append(s[i + 1])
            i += 2
        else:
            result.append(s[i])
            i += 1
    return ''.join(result)


def generate_elf_header():
    add_bytes([0x7F, 0x45, 0x4C, 0x46], "ELF magic")
    add_byte(2, "ELFCLASS64")
    add_byte(1, "ELFDATA2LSB")
    add_byte(1, "ELF version")
    add_byte(0, "OS ABI")
    add_byte(0, "ABI version")
    add_bytes([0] * 7, "Padding")
    
    add_word16(2, "e_type = ET_EXEC")
    add_word16(62, "e_machine = EM_X86_64")
    add_word32(1, "e_version")
    
    add_word64(0, "e_entry (stub)")
    
    add_word64(64, "e_phoff")
    add_word64(0, "e_shoff = 0")
    
    add_word32(0, "e_flags")
    add_word16(64, "e_ehsize")
    add_word16(56, "e_phentsize")
    
    add_word16(2, "e_phnum = 2")
    add_word16(0, "e_shentsize = 0")
    add_word16(0, "e_shnum = 0")
    add_word16(0, "e_shstrndx")


def generate_program_headers():
    add_word32(1, "p_type = PT_LOAD")
    add_word32(5, "p_flags = RX")
    add_word64(0, "p_offset (text stub)")
    add_word64(vaddr_text, "p_vaddr (text)")
    add_word64(vaddr_text, "p_paddr (text)")
    add_word64(0, "p_filesz (text stub)")
    add_word64(0, "p_memsz (text stub)")
    add_word64(PAGE_SIZE, "p_align")
    
    add_word32(1, "p_type = PT_LOAD")
    add_word32(6, "p_flags = RW")
    add_word64(0, "p_offset (data stub)")
    add_word64(0, "p_vaddr (data stub)")
    add_word64(0, "p_paddr (data stub)")
    add_word64(0, "p_filesz (data stub)")
    add_word64(0, "p_memsz (data stub)")
    add_word64(PAGE_SIZE, "p_align")


def read_ast(input_file):
    with open(input_file, 'r', encoding='utf-8') as f:
        return [line.strip() for line in f]


def parse_ast_line(line):
    if not line:
        return None, {}
    
    line_type = line.split(':')[0]
    
    if line_type == "INSTR":
        first = line.find(':')
        second = line.find(':', first + 1)
        third = line.find(':', second + 1)
        
        if first == -1 or second == -1 or third == -1:
            return "INSTR", {}
        
        mnemonic = line[first + 1:second]
        section = line[second + 1:third]
        operands_str = line[third + 1:]
        operands = operands_str.split(',') if operands_str else []
        
        return "INSTR", {
            'mnemonic': mnemonic,
            'section': section,
            'operands': operands
        }
    
    elif line_type == "DIRECTIVE":
        # Разбиваем максимум на 4 части: DIRECTIVE, имя, секция, остальное
        parts = line.split(':', 3)
        directive = parts[1] if len(parts) > 1 else ""
        
        if directive in ('.текст', '.данные', '.бнд'):
            return "DIRECTIVE", {'directive': directive}
        elif directive == '.глобал':
            return "DIRECTIVE", {'directive': directive, 'label': parts[2] if len(parts) > 2 else ""}
        elif directive in ('.строка', '.строка_нуль'):
            return "DIRECTIVE", {
                'directive': directive,
                'section': parts[2] if len(parts) > 2 else "",
                'string': parts[3] if len(parts) > 3 else ""  # ← вся оставшаяся строка
            }
        elif directive == '.константа':
            return "DIRECTIVE", {
                'directive': directive,
                'name': parts[2] if len(parts) > 2 else "",
                'value': parts[3] if len(parts) > 3 else ""
            }
        elif directive == '.байт':
            return "DIRECTIVE", {
                'directive': directive,
                'section': parts[2] if len(parts) > 2 else "",
                'bytes': parts[3] if len(parts) > 3 else ""
            }
        elif directive in ('.резб', '.резс', '.рездс', '.резкс'):
            return "DIRECTIVE", {
                'directive': directive,
                'section': parts[2] if len(parts) > 2 else "",
                'count': parts[3] if len(parts) > 3 else "0"
            }
        else:
            return "DIRECTIVE", {'directive': directive}
    
    elif line_type == "LABEL":
        parts = line.split(':')
        return "LABEL", {
            'name': parts[1] if len(parts) > 1 else "",
            'section': parts[2] if len(parts) > 2 else ""
        }
    
    return line_type, {}

def get_stub_size(mnemonic, operands):
    if mnemonic in ("переход", "вызвать"):
        return 5
    elif mnemonic == "короткий_переход":
        return 2
    elif mnemonic.startswith("переход_если") and not mnemonic.startswith("короткий"):
        return 6
    elif mnemonic.startswith("короткий_переход_если"):
        return 2
    elif mnemonic == "цикл":
        return 2
    elif mnemonic == "переместить_имм" and len(operands) >= 2:
        reg = operands[0]
        if reg in ('раикс', 'рбикс', 'рсикс', 'рдикс', 'рсипи', 'рбипи', 'рсиай', 'рдиай',
                   'р8', 'р9', 'р10', 'р11', 'р12', 'р13', 'р14', 'р15'):
            return 10
        elif reg in ('еаикс', 'ебикс', 'есикс', 'едикс'):
            return 7
        else:
            return 2
    elif mnemonic in ("загрузить", "сохранить", "загрузить_адрес"):
        return 7
    elif mnemonic == "сравнить_с":
        return 7
    elif mnemonic in ("прибавить_непосредственно", "вычесть_непосредственно"):
        return 7
    elif mnemonic in ("переместить_с_нулями", "переместить_со_знаком"):
        return 7
    return 1


def extract_label_from_operands(operands):
    for op in operands:
        if not op:
            continue
        if op in ('раикс', 'рбикс', 'рсикс', 'рдикс', 'рсипи', 'рбипи', 'рсиай', 'рдиай',
                  'еаикс', 'ебикс', 'есикс', 'едикс',
                  'аикс', 'бикс', 'сикс', 'дикс',
                  'ал', 'бл', 'кл', 'дл',
                  'р8', 'р9', 'р10', 'р11', 'р12', 'р13', 'р14', 'р15'):
            continue
        if op.isdigit() or (op.startswith('0x') and len(op) > 2):
            continue
        if op.startswith('MEM:reg_indirect:'):
            continue
        if op.startswith('[') and op.endswith(']'):
            inner = op[1:-1]
            if inner not in ('раикс', 'рбикс', 'рсикс', 'рдикс', 'рсипи', 'рбипи', 'рсиай', 'рдиай'):
                if not inner.isdigit() and not inner.startswith('0x'):
                    return inner
        elif op not in symbols:
            return op
    return None


def has_unresolved_labels(operands, mnemonic=""):
    if mnemonic in ALWAYS_STUB_INSTRUCTIONS:
        for op in operands:
            if op and not op.isdigit() and not op.startswith('0x'):
                if op not in ('раикс', 'рбикс', 'рсикс', 'рдикс', 'рсипи', 'рбипи', 'рсиай', 'рдиай',
                              'еаикс', 'ебикс', 'есикс', 'едикс',
                              'аикс', 'бикс', 'сикс', 'дикс',
                              'ал', 'бл', 'кл', 'дл'):
                    return True
    
    for op in operands:
        if not op:
            continue
        if op in ('раикс', 'рбикс', 'рсикс', 'рдикс', 'рсипи', 'рбипи', 'рсиай', 'рдиай',
                  'еаикс', 'ебикс', 'есикс', 'едикс',
                  'аикс', 'бикс', 'сикс', 'дикс',
                  'ал', 'бл', 'кл', 'дл',
                  'р8', 'р9', 'р10', 'р11', 'р12', 'р13', 'р14', 'р15',
                  'р8д', 'р9д', 'р10д', 'р11д', 'р12д', 'р13д', 'р14д', 'р15д',
                  'р8в', 'р9в', 'р10в', 'р11в', 'р12в', 'р13в', 'р14в', 'р15в',
                  'р8б', 'р9б', 'р10б', 'р11б', 'р12б', 'р13б', 'р14б', 'р15б',
                  'спл', 'бпл', 'сил', 'дил'):
            continue
        if op.startswith('MEM:reg_indirect:'):
            continue
        if op.startswith('[') and op.endswith(']'):
            inner = op[1:-1]
            if inner in ('раикс', 'рбикс', 'рсикс', 'рдикс', 'рсипи', 'рбипи', 'рсиай', 'рдиай'):
                continue
            if inner.isdigit() or (inner.startswith('0x') and len(inner) > 2):
                continue
            if inner not in labels:
                return True
            continue
        if op.isdigit() or (op.startswith('0x') and len(op) > 2):
            continue
        if op in symbols:
            continue
        if op not in labels:
            return True
    
    return False


def get_unresolved_labels(operands):
    unresolved = []
    for op in operands:
        if not op:
            continue
        if op.startswith('[') and op.endswith(']'):
            inner = op[1:-1]
            if inner not in labels and not inner.isdigit() and not (inner.startswith('0x')):
                if inner not in ('раикс', 'рбикс', 'рсикс', 'рдикс', 'рсипи', 'рбипи', 'рсиай', 'рдиай'):
                    if inner not in symbols:
                        unresolved.append(inner)
        elif op not in labels and not op.isdigit() and not (op.startswith('0x')):
            if op not in ('раикс', 'рбикс', 'рсикс', 'рдикс', 'рсипи', 'рбипи', 'рсиай', 'рдиай',
                          'еаикс', 'ебикс', 'есикс', 'едикс',
                          'аикс', 'бикс', 'сикс', 'дикс',
                          'ал', 'бл', 'кл', 'дл',
                          'р8', 'р9', 'р10', 'р11', 'р12', 'р13', 'р14', 'р15'):
                if op not in symbols:
                    unresolved.append(op)
    return unresolved


def process_ast_line(line):
    global text_pos, data_pos, vaddr_data, vaddr_bnd, bss_size
    global text_buffer, data_buffer, entry_point, symbols, pending_labels
    
    line_type, fields = parse_ast_line(line)
    
    if line_type == "DIRECTIVE":
        directive = fields.get('directive', '')
        
        if directive == '.текст':
            set_segment('.text')
        
        elif directive == '.данные':
            set_segment('.data')
            align_to(PAGE_SIZE)
            global data_offset
            data_offset = align_up(0x1000 + text_pos, PAGE_SIZE)
            print(f"  .data: пересчитан data_offset = 0x{data_offset:x} (text_pos={text_pos})")
        
        elif directive == '.бнд':
            set_segment('.bss')
            # Инициализируем vaddr_bnd когда входим в BSS
            if vaddr_bnd is None:
                data_vaddr = vaddr_data if vaddr_data else align_up(vaddr_text + text_pos, PAGE_SIZE)
                vaddr_bnd = align_up(data_vaddr + data_pos, PAGE_SIZE)
        
        elif directive == '.глобал':
            entry_point = fields.get('label', '_start')
        
        elif directive == '.константа':
            name = fields.get('name', '')
            value_str = fields.get('value', '')
            if value_str.startswith('0x') or value_str.startswith('0X'):
                value = int(value_str, 16)
            else:
                value = int(value_str)
            symbols[name] = value
            print(f"  константа: {name} = {value}")
        
        elif directive in ('.строка', '.строка_нуль'):
            s = fields.get('string', '')
            real_s = unescape_string(s)
            bstring = real_s.encode('utf-8')
            if directive == '.строка_нуль':
                bstring += b'\x00'
            
            source = f'{directive} "{s}"'
            
            for i, byte in enumerate(bstring):
                labels_list = pending_labels if i == 0 else None
                add_byte(byte, source if i == 0 else "", None, labels_list)
                data_buffer.append(byte)
                if labels_list:
                    pending_labels = []
            data_pos += len(bstring)
        
        elif directive == '.байт':
            bytes_str = fields.get('bytes', '')
            if bytes_str:
                byte_values = bytes_str.split(',')
                source = f'.байт {bytes_str}'
                bstring = bytearray()
                for byte_str in byte_values:
                    byte_str = byte_str.strip()
                    if byte_str.startswith('0x'):
                        val = int(byte_str, 16)
                    else:
                        val = int(byte_str)
                    bstring.append(val & 0xFF)
                
                for i, byte in enumerate(bstring):
                    labels_list = pending_labels if i == 0 else None
                    add_byte(byte, source if i == 0 else "", None, labels_list)
                    data_buffer.append(byte)
                    if labels_list:
                        pending_labels = []
                data_pos += len(bstring)
        
        elif directive in ('.резб', '.резс', '.рездс', '.резкс'):
            count = int(fields.get('count', '0'))
            multiplier = {'резб': 1, 'резс': 2, 'рездс': 4, 'резкс': 8}
            size = count * multiplier.get(directive, 1)
            
            # Добавляем BSS в CSV
            label_name = pending_labels[0] if pending_labels else None
            add_bss_entry(size, label_name)
            
            if label_name and pending_labels:
                pending_labels = []
    
    elif line_type == "LABEL":
        label_name = fields.get('name', '')
        sec = fields.get('section', '')
        
        if sec == '.text':
            addr = vaddr_text + text_pos
            labels[label_name] = addr
            label_sections[label_name] = sec
            if label_name not in pending_labels:
                pending_labels.append(label_name)
        
        elif sec == '.data':
            if vaddr_data is None:
                vaddr_data = align_up(vaddr_text + text_pos, PAGE_SIZE)
            addr = vaddr_data + data_pos
            labels[label_name] = addr
            label_sections[label_name] = sec
            if label_name not in pending_labels:
                pending_labels.append(label_name)
        
        elif sec == '.бнд':
            if vaddr_bnd is None:
                data_vaddr = vaddr_data if vaddr_data else align_up(vaddr_text + text_pos, PAGE_SIZE)
                vaddr_bnd = align_up(data_vaddr + data_pos, PAGE_SIZE)
            addr = vaddr_bnd + bss_size
            labels[label_name] = addr
            label_sections[label_name] = sec
            if label_name not in pending_labels:
                pending_labels.append(label_name)
        
        else:
            addr = current_address
            labels[label_name] = addr
            label_sections[label_name] = sec
            if label_name not in pending_labels:
                pending_labels.append(label_name)
    
    elif line_type == "INSTR":
        mnemonic = fields.get('mnemonic', '')
        sec = fields.get('section', '')
        operands = fields.get('operands', [])
        
        source = f"{mnemonic} {', '.join(operands)}" if operands else mnemonic
        
        need_stub = has_unresolved_labels(operands, mnemonic)
        
        if need_stub:
            stub_size = get_stub_size(mnemonic, operands)
            unresolved = get_unresolved_labels(operands)
            
            if unresolved:
                reloc_text = f"ЗАГЛУШКА {', '.join(unresolved)}"
            else:
                label_from_op = extract_label_from_operands(operands)
                if label_from_op:
                    reloc_text = f"ЗАГЛУШКА {label_from_op}"
                else:
                    reloc_text = "ЗАГЛУШКА (неизвестная метка)"
            
            relocations.append({
                'address': current_address,
                'size': stub_size,
                'labels': unresolved if unresolved else [label_from_op] if label_from_op else [],
                'source': source,
                'mnemonic': mnemonic
            })
            
            for i in range(stub_size):
                labels_list = pending_labels if i == 0 else None
                add_byte(0xCC, source if i == 0 else "", reloc_text if i == 0 else None, labels_list)
                if labels_list:
                    pending_labels = []
            
            if sec == '.text':
                text_buffer.extend([0xCC] * stub_size)
                text_pos += stub_size
            else:
                data_buffer.extend([0xCC] * stub_size)
                data_pos += stub_size
        else:
            try:
                if sec == '.text':
                    current_pos = text_pos
                else:
                    current_pos = data_pos
                
                encoded = encode_instruction(
                    mnemonic, operands, labels, label_sections, symbols,
                    vaddr_text, vaddr_data if vaddr_data else 0,
                    current_pos, vaddr_bnd if vaddr_bnd else 0
                )
                
                for i, byte in enumerate(encoded):
                    labels_list = pending_labels if i == 0 else None
                    add_byte(byte, source if i == 0 else "", None, labels_list)
                    if labels_list:
                        pending_labels = []
                
                if sec == '.text':
                    text_buffer.extend(encoded)
                    text_pos += len(encoded)
                else:
                    data_buffer.extend(encoded)
                    data_pos += len(encoded)
                    
            except Exception as e:
                print(f"Ошибка кодирования {source}: {e}", file=sys.stderr)
                labels_to_attach = pending_labels.copy()
                add_byte(0xCC, source, f"ОШИБКА: {e}", labels_to_attach)
                pending_labels.clear()
                
                if sec == '.text':
                    text_buffer.append(0xCC)
                    text_pos += 1
                else:
                    data_buffer.append(0xCC)
                    data_pos += 1


def finalize_headers():
    global entries, data_offset, vaddr_data, vaddr_bnd
    
    print("\n[DEBUG finalize_headers] Начало")
    
    text_offset = 0x1000
    text_filesz = len(text_buffer)
    text_memsz = len(text_buffer)
    
    # Выравнивание для начала секции данных
    data_offset = align_up(text_offset + text_filesz, PAGE_SIZE)
    print(f"[DEBUG] text_filesz={text_filesz}, data_offset=0x{data_offset:x}")
    
    data_filesz = len(data_buffer)
    
    # Вычисляем виртуальные адреса с учётом выравнивания на PAGE_SIZE
    vaddr_data_start = align_up(vaddr_text + text_filesz, PAGE_SIZE)
    vaddr_bss_start = align_up(vaddr_data_start + data_filesz, PAGE_SIZE)
    
    # Сохраняем в глобальные переменные
    vaddr_data = vaddr_data_start
    vaddr_bnd = vaddr_bss_start
    
    # memsz должен покрывать всё: от начала .data до конца .bss
    # Важно: включаем выравнивание между .data и .bss!
    data_memsz = (vaddr_bss_start + bss_size) - vaddr_data_start
    
    print(f"[DEBUG] vaddr_data_start=0x{vaddr_data_start:x}")
    print(f"[DEBUG] vaddr_bss_start=0x{vaddr_bss_start:x}")
    print(f"[DEBUG] data_filesz={data_filesz}, bss_size={bss_size}")
    print(f"[DEBUG] data_memsz={data_memsz} (файл: {data_filesz}, память: {data_memsz})")
    
    # Обновляем виртуальные адреса для BSS записей в CSV
    for i, entry in enumerate(entries):
        if entry[0] == ".bss" and entry[1] == "BSS":
            old_virt = int(entry[2], 16)
            # Вычисляем смещение внутри BSS
            bss_offset = old_virt - vaddr_bss_start if vaddr_bss_start else 0
            new_virt = vaddr_bss_start + bss_offset
            entries[i] = (entry[0], entry[1], f"0x{new_virt:08x}", entry[3], 
                         entry[4], entry[5], entry[6], entry[7], entry[8], entry[9])
            print(f"[DEBUG] BSS запись: virt 0x{old_virt:x} -> 0x{new_virt:x}")
    
    entry_point_addr = labels.get(entry_point, vaddr_text)
    print(f"[DEBUG] entry_point_addr=0x{entry_point_addr:x}")
    
    i = 0
    while i < len(entries):
        segment, addr, virt_addr, byte_str, target, source, label, cmd_with_values, calc_target, calc_byte = entries[i]
        
        # Пропускаем BSS-записи (они уже обработаны выше)
        if segment == ".bss":
            i += 1
            continue
        
        # Заполнение точки входа
        if 'e_entry (stub)' in source:
            new_bytes = struct.pack('<Q', entry_point_addr)
            for j, nb in enumerate(new_bytes):
                virt = f"0x{entry_point_addr + j:08x}"
                byte_hex = f"0x{nb:02x}"
                entries[i + j] = (segment, addr + j, virt, byte_hex, target, 
                                  f"e_entry = 0x{entry_point_addr:x}", 
                                  label if j == 0 else "", 
                                  "", "", byte_hex)
            i += 8
            continue
        
        # Заполнение смещения текстовой секции
        elif 'p_offset (text stub)' in source:
            new_bytes = struct.pack('<Q', text_offset)
            for j, nb in enumerate(new_bytes):
                virt = f"0x{addr + j:08x}"
                byte_hex = f"0x{nb:02x}"
                entries[i + j] = (segment, addr + j, virt, byte_hex, target, 
                                  f"p_offset (text) = 0x{text_offset:x}", 
                                  label if j == 0 else "", 
                                  "", "", byte_hex)
            i += 8
            continue
        
        # Заполнение размера текстовой секции в файле
        elif 'p_filesz (text stub)' in source:
            new_bytes = struct.pack('<Q', text_filesz)
            for j, nb in enumerate(new_bytes):
                virt = f"0x{addr + j:08x}"
                byte_hex = f"0x{nb:02x}"
                entries[i + j] = (segment, addr + j, virt, byte_hex, target, 
                                  f"p_filesz (text) = {text_filesz}", 
                                  label if j == 0 else "", 
                                  "", "", byte_hex)
            i += 8
            continue
        
        # Заполнение размера текстовой секции в памяти
        elif 'p_memsz (text stub)' in source:
            new_bytes = struct.pack('<Q', text_memsz)
            for j, nb in enumerate(new_bytes):
                virt = f"0x{addr + j:08x}"
                byte_hex = f"0x{nb:02x}"
                entries[i + j] = (segment, addr + j, virt, byte_hex, target, 
                                  f"p_memsz (text) = {text_memsz}", 
                                  label if j == 0 else "", 
                                  "", "", byte_hex)
            i += 8
            continue
        
        # Заполнение смещения секции данных
        elif 'p_offset (data stub)' in source:
            new_bytes = struct.pack('<Q', data_offset)
            for j, nb in enumerate(new_bytes):
                virt = f"0x{addr + j:08x}"
                byte_hex = f"0x{nb:02x}"
                entries[i + j] = (segment, addr + j, virt, byte_hex, target, 
                                  f"p_offset (data) = 0x{data_offset:x}", 
                                  label if j == 0 else "", 
                                  "", "", byte_hex)
            i += 8
            continue
        
        # Заполнение виртуального адреса секции данных
        elif 'p_vaddr (data stub)' in source:
            new_bytes = struct.pack('<Q', vaddr_data_start)
            for j, nb in enumerate(new_bytes):
                virt = f"0x{vaddr_data_start + j:08x}"
                byte_hex = f"0x{nb:02x}"
                entries[i + j] = (segment, addr + j, virt, byte_hex, target, 
                                  f"p_vaddr (data) = 0x{vaddr_data_start:x}", 
                                  label if j == 0 else "", 
                                  "", "", byte_hex)
            i += 8
            continue
        
        # Заполнение физического адреса секции данных
        elif 'p_paddr (data stub)' in source:
            new_bytes = struct.pack('<Q', vaddr_data_start)
            for j, nb in enumerate(new_bytes):
                virt = f"0x{vaddr_data_start + j:08x}"
                byte_hex = f"0x{nb:02x}"
                entries[i + j] = (segment, addr + j, virt, byte_hex, target, 
                                  f"p_paddr (data) = 0x{vaddr_data_start:x}", 
                                  label if j == 0 else "", 
                                  "", "", byte_hex)
            i += 8
            continue
        
        # Заполнение размера секции данных в файле
        elif 'p_filesz (data stub)' in source:
            new_bytes = struct.pack('<Q', data_filesz)
            for j, nb in enumerate(new_bytes):
                virt = f"0x{addr + j:08x}"
                byte_hex = f"0x{nb:02x}"
                entries[i + j] = (segment, addr + j, virt, byte_hex, target, 
                                  f"p_filesz (data) = {data_filesz}", 
                                  label if j == 0 else "", 
                                  "", "", byte_hex)
            i += 8
            continue
        
        # Заполнение размера секции данных в памяти (ВКЛЮЧАЯ BSS И ВЫРАВНИВАНИЕ!)
        elif 'p_memsz (data stub)' in source:
            new_bytes = struct.pack('<Q', data_memsz)
            for j, nb in enumerate(new_bytes):
                virt = f"0x{addr + j:08x}"
                byte_hex = f"0x{nb:02x}"
                entries[i + j] = (segment, addr + j, virt, byte_hex, target, 
                                  f"p_memsz (data) = {data_memsz} (data: {data_filesz}, bss: {bss_size}, выравнивание: {data_memsz - data_filesz - bss_size})", 
                                  label if j == 0 else "", 
                                  "", "", byte_hex)
            i += 8
            continue
        
        i += 1
    
    print("[DEBUG finalize_headers] Завершено")

def save_to_csv(filename: str):
    with open(filename, 'w', newline='', encoding='utf-8') as f:
        writer = csv.writer(f, delimiter=';')
        writer.writerow(['сегмент', 'адрес', 'виртуальный_адрес', 'байт', 'приводящая_метка', 
                         'уводящий_адрес', 'исходная_команда', 'команда_со_значениями',
                         'рассчитанный_уводящий_адрес', 'рассчитанный_байт'])
        
        for segment, addr, virt_addr, byte_str, target, source, label, cmd_with_values, calc_target, calc_byte in entries:
            writer.writerow([
                segment,
                f"0x{addr:08x}" if isinstance(addr, int) else addr,
                virt_addr,
                byte_str,
                label,
                target,
                source,
                cmd_with_values,
                calc_target,
                calc_byte
            ])


def print_section_info():
    text_start_offset = 0x1000
    text_end_offset = text_start_offset + len(text_buffer)
    text_end_aligned = align_up(text_end_offset, PAGE_SIZE)
    
    data_start_offset = text_end_aligned
    data_end_offset = data_start_offset + len(data_buffer)
    data_end_aligned = align_up(data_end_offset, PAGE_SIZE)
    
    print(f"\n=== Информация о размещении секций (файловые смещения) ===")
    print(f"  .text: {len(text_buffer)} байт, смещение 0x{text_start_offset:x} - 0x{text_end_offset-1:x}")
    print(f"         выровнено: следующий сектор начнётся с 0x{text_end_aligned:x}")
    print(f"  .data: {len(data_buffer)} байт, смещение 0x{data_start_offset:x} - 0x{data_end_offset-1:x}")
    print(f"         выровнено: следующий сектор начнётся с 0x{data_end_aligned:x}")
    if bss_size > 0:
        print(f"  .bnd:  {bss_size} байт (только в памяти, не в файле)")
    
    print(f"\n=== Виртуальные адреса ===")
    print(f"  .text: 0x{vaddr_text:x} - 0x{vaddr_text + len(text_buffer) - 1:x}")
    data_vaddr = align_up(vaddr_text + len(text_buffer), PAGE_SIZE)
    print(f"  .data: 0x{data_vaddr:x} - 0x{data_vaddr + len(data_buffer) - 1:x}")
    if bss_size > 0:
        bnd_vaddr = align_up(data_vaddr + len(data_buffer), PAGE_SIZE)
        print(f"  .bnd:  0x{bnd_vaddr:x} - 0x{bnd_vaddr + bss_size - 1:x}")


def main():
    if len(sys.argv) != 3:
        print("Использование: python kvs_pass1.py <вход.аст> <выход.csv>")
        sys.exit(1)
    
    ast_file = sys.argv[1]
    csv_file = sys.argv[2]
    
    reset_state()
    
    set_segment('.header')
    generate_elf_header()
    generate_program_headers()
    align_to(PAGE_SIZE)
    
    ast_lines = read_ast(ast_file)
    for line in ast_lines:
        process_ast_line(line)
    
    finalize_headers()
    save_to_csv(csv_file)
    print_section_info()
    
    vaddr_data_final = align_up(vaddr_text + len(text_buffer), PAGE_SIZE)
    vaddr_bnd_final = align_up(vaddr_data_final + len(data_buffer), PAGE_SIZE)
    
    print(f"\n=== Первый проход ===")
    print(f"  .text: {len(text_buffer)} байт, vaddr=0x{vaddr_text:x}")
    print(f"  .data: {len(data_buffer)} байт, vaddr=0x{vaddr_data_final:x}, offset=0x{align_up(0x1000 + len(text_buffer), PAGE_SIZE):x}")
    print(f"  .bnd:  {bss_size} байт, vaddr=0x{vaddr_bnd_final:x} (только в памяти)")
    print(f"  точка входа: {entry_point} = 0x{labels.get(entry_point, vaddr_text):x}")
    print(f"  меток: {len(labels)}")
    print(f"  констант: {len(symbols)}")
    print(f"  релокаций: {len(relocations)}")
    print(f"  записей: {len(entries)}")
    print(f"  CSV: {csv_file}")


if __name__ == "__main__":
    main()