import ast
import copy
from helper import *
from type_def import *
from inference import *
from parse_expr import parse_expr, parse_simple_binding

def parse_stmts(ctx: Context,
                sym_table: dict[str, Type],
                used_sym_table: dict[str, Type],
                return_ty: Type,
                nodes):
    sym_table2 = copy.copy(sym_table)
    used_sym_table2 = copy.copy(used_sym_table)
    for node in nodes:
        if isinstance(node, ast.Assign):
            a, b, returned = parse_assign(ctx, sym_table2, used_sym_table2, return_ty, node)
        elif isinstance(node, ast.If):
            a, b, returned = parse_if_stmt(ctx, sym_table2, used_sym_table2, return_ty, node)
        elif isinstance(node, ast.While):
            a, b, returned = parse_while_stmt(ctx, sym_table2, used_sym_table2, return_ty, node)
        elif isinstance(node, ast.For):
            a, b, returned = parse_for_stmt(ctx, sym_table2, used_sym_table2, return_ty, node)
        elif isinstance(node, ast.Return):
            a, b, returned = parse_return_stmt(ctx, sym_table2, used_sym_table2, return_ty, node)
        elif isinstance(node, ast.Break) or isinstance(node, ast.Continue):
            continue
        else:
            raise CustomError(f'{node} is not supported yet')
        sym_table2 |= a
        used_sym_table2 |= b
        if returned:
            return sym_table2, used_sym_table2, True
    return sym_table2, used_sym_table2, False

def get_target_type(ctx: Context,
                    sym_table: dict[str, Type],
                    used_sym_table: dict[str, Type],
                    target):
    if isinstance(target, ast.Subscript):
        t = get_target_type(ctx, sym_table, used_sym_table, target.value)
        if not isinstance(t, ListType):
            raise CustomError(f'cannot index through type {t}')
        if isinstance(target.slice, ast.Slice):
            raise CustomError(f'assignment to slice is not supported')
        i = parse_expr(ctx, sym_table, target.slice)
        if i != ctx.types['int32']:
            raise CustomError(f'index must be int32')
        return t.params[0]
    elif isinstance(target, ast.Attribute):
        t = get_target_type(ctx, sym_table, used_sym_table, target.value)
        if target.attr not in t.fields:
            raise CustomError(f'{t} has no field {target.attr}')
        return t.fields[target.attr]
    elif isinstance(target, ast.Name):
        if target.id not in sym_table:
            raise CustomError(f'unbounded {target.id}')
        return sym_table[target.id]
    else:
        raise CustomError(f'assignment to {target} is not supported')

def parse_stmt_binding(ctx: Context,
                       sym_table: dict[str, Type],
                       used_sym_table: dict[str, Type],
                       target,
                       ty):
    if isinstance(target, ast.Name):
        if target.id in used_sym_table:
            if used_sym_table[target.id] != ty:
                raise CustomError('inconsistent type')
        if target.id == '_':
            return {}
        return {target.id: ty}
    elif isinstance(target, ast.Tuple):
        if not isinstance(ty, TupleType):
            raise CustomError(f'cannot pattern match over {ty}')
        if len(target.elts) != len(ty.params):
            raise CustomError(f'pattern matching length mismatch')
        result = {}
        for x, y in zip(target.elts, ty.params):
            new = parse_stmt_binding(ctx, sym_table, used_sym_table, x, y)
            old_len = len(result)
            result |= new
            used_sym_table |= new
            if len(result) != old_len + len(new):
                raise CustomError(f'variable name clash')
        return result
    else:
        t = get_target_type(ctx, sym_table, used_sym_table, target)
        if ty != t:
            raise CustomError(f'inconsistent type')
        return {}

def parse_assign(ctx: Context,
                 sym_table: dict[str, Type],
                 used_sym_table: dict[str, Type],
                 return_ty: Type,
                 node):
    # permitted assignment targets:
    # variables, class fields, list elements
    # function evaluation is only allowed within list index
    # may relax later after when we settle on lifetime handling
    ty = parse_expr(ctx, sym_table, node.value)
    results = {}
    for target in node.targets:
        results |= parse_stmt_binding(ctx, sym_table, used_sym_table, target, ty)
    return results, results, False

def parse_if_stmt(ctx: Context,
                  sym_table: dict[str, Type],
                  used_sym_table: dict[str, Type],
                  return_ty: Type,
                  node):
    test = parse_expr(ctx, sym_table, node.test)
    if test != ctx.types['bool']:
        raise CustomError(f'condition must be bool instead of {test}')
    a, b, r = parse_stmts(ctx, sym_table, used_sym_table, return_ty, node.body)
    used_sym_table |= b
    a1, b1, r1 = parse_stmts(ctx, sym_table, used_sym_table, return_ty, node.orelse)
    defined = {k: a[k] for k in a if k in a1}
    return defined, b | b1, r and r1

def parse_for_stmt(ctx: Context,
                   sym_table: dict[str, Type],
                   used_sym_table: dict[str, Type],
                   return_ty: Type,
                   node):
    ty = parse_expr(ctx, sym_table, node.iter)
    if not isinstance(ty, ListType):
        raise CustomError('only iteration over list is supported')
    binding = parse_simple_binding(node.target, ty.params[0])
    for key, value in binding.items():
        if key in used_sym_table:
            if value != used_sym_table[key]:
                raise CustomError('inconsistent type')
    # more sophisticated return analysis is needed...
    a, b, _ = parse_stmts(ctx, sym_table | binding, used_sym_table | binding,
                          return_ty, node.body)
    a1, b1, _ = parse_stmts(ctx, sym_table, used_sym_table | b,
                          return_ty, node.orelse)
    defined = {k: a[k] for k in a if k in a1}
    return defined, b | b1, False

def parse_while_stmt(ctx: Context,
                     sym_table: dict[str, Type],
                     used_sym_table: dict[str, Type],
                     return_ty: Type,
                     node):
    ty = parse_expr(ctx, sym_table, node.test)
    if ty != ctx.types['bool']:
        raise CustomError('condition must be bool')
    # more sophisticated return analysis is needed...
    a, b, _ = parse_stmts(ctx, sym_table, used_sym_table, return_ty, node.body)
    a1, b1, _ = parse_stmts(ctx, sym_table, used_sym_table | b,
                             return_ty, node.orelse)
    defined = {k: a[k] for k in a if k in a1}
    return defined, b | b1, False

def parse_return_stmt(ctx: Context,
                      sym_table: dict[str, Type],
                      used_sym_table: dict[str, Type],
                      return_ty: Type,
                      node):
    if return_ty is None:
        if node.value is not None:
            raise CustomError('no return value is allowed')
        return {}, {}, True
    ty = parse_expr(ctx, sym_table, node.value)
    if ty != return_ty:
        raise CustomError(f'expected returning {return_ty} but got {ty}')
    return {}, {}, True