import os

from transformers import DataCollatorForSeq2Seq,LogitsProcessor,LogitsProcessorList, AutoModelForCausalLM
import torch

from tree.asts import ASC,Node

class OutputControlLogitsProcessor(LogitsProcessor):
    def __init__(self, tokenizer,ast):
        self.tokenizer = tokenizer
        self.ast = ast    
        self.trigger = tokenizer.encode('<e>')[-3:]

    def _get_valid_token_ids(self):       
        valid_tokens = self.ast.return_next_token()
        valid_ids = []

        if len(valid_tokens) == 0:
            return list(range(len(self.tokenizer.get_vocab())))
        
        for token in valid_tokens:
            token_id = self.tokenizer.convert_tokens_to_ids(token)
            if token_id != self.tokenizer.unk_token_id:
                valid_ids.append(token_id)
       
        return valid_ids

    def __call__(self, input_ids, scores):
        if input_ids[0,-3:].tolist() != self.trigger:
            return scores
        
        last_token = input_ids[0, -1].item()
        last_token = self.tokenizer.decode([last_token], skip_special_tokens=False)

        self.ast.update_state(last_token)
        current_ids = self._get_valid_token_ids()

        mask = torch.full_like(scores, -float(1e10))
        for ids in current_ids:
            mask[:, ids] = 0
             
        filtered_scores = scores + mask
        
        return filtered_scores

class RewardControlLogitsProcessor(LogitsProcessor):
    def __init__(self, tokenizer, open_tag='<v>',close_tag='</v>',lower=0,upper=100):
        self.tokenizer = tokenizer
        
        open_tag = tokenizer.encode(open_tag, add_special_tokens=False)
        close_tag = tokenizer.encode(close_tag, add_special_tokens=False)
        number_tokens = [tokenizer.encode(str(i), add_special_tokens=False) for i in ['接受','拒绝']]

        self.tag_tokens =  {"open_tag": open_tag,"close_tag": close_tag,"label": number_tokens}
        self.get_tag_chain()

    def get_tag_chain(self):     
        asc = ASC()
        current_node = asc.root
        for i,t in enumerate(self.tag_tokens['open_tag']):
            node = Node(t)
            current_node.children[t] = node
            current_node = node
        end_node = None
        end = '</v>'
        for i,t in enumerate(self.tag_tokens['close_tag']):
            if i == 0:        
                end_node = Node(t)
                _end_node = end_node
                end = t
            else:
                node = Node(t)
                _end_node.children[t] = node
                _end_node = node
            if i == len(self.tag_tokens['close_tag']) - 1:
                node = Node('')
                node.end = True
                _end_node.children[t] = node

        for t in self.tag_tokens['label']:
            for c in t:
                node = Node(c)
                current_node.children[c] = node
                current_node = node
            current_node.children[end] = end_node

        self.asc = asc
   
    def __call__(self, input_ids, scores):
        if self.asc.current_node.end:
            return scores

        last_token = input_ids[0, -1].item()
        self.asc.update_state(last_token)

        mask = torch.full_like(scores, -float(1e8))
        for ids in [list(self.asc.current_node.children.keys())]:
            mask[:, ids] = 0      
        filtered_scores = scores + mask

        return filtered_scores

if __name__ == '__main__':
    from transformers import AutoTokenizer, AutoModelForCausalLM
    from tree.asts import AST

    # 加载模型和tokenizer
    model_name = ''
    tokenizer = AutoTokenizer.from_pretrained(model_name)
    model = AutoModelForCausalLM.from_pretrained(model_name)

    # 初始化语法树
    syntax_tree = AST('./codekey_proofread.txt')

    # 创建logits processor
    logits_processor = OutputControlLogitsProcessor(syntax_tree, tokenizer)

    input_text = "eqwmdsadas乱码"
    input_ids = tokenizer.encode(input_text, return_tensors="pt")

    output = model.generate(
    input_ids,
    max_length=50,
    do_sample=True,
    num_return_sequences=1,
    logits_processor=[logits_processor],
    pad_token_id=tokenizer.eos_token_id
)


    decoded_output = tokenizer.decode(output[0], skip_special_tokens=False)
    print(decoded_output)