from otree.api import Currency as c, currency_range
from . import pages
from ._builtin import Bot
from .models import C,Player
from html.parser import HTMLParser

class MyHTMLParser(HTMLParser):
    def __init__(self):
        super().__init__()
        self.fields = {}

    def handle_starttag(self, tag, attrs):
        if tag in ['input', 'select', 'textarea']:
            attrs_dict = dict(attrs)
            field_name = attrs_dict.get('name')
            if field_name:
                if tag == 'select':
                    self.fields[field_name] = []
                elif tag == 'input' and attrs_dict.get('type') == 'radio':
                    value = attrs_dict.get('value', '')
                    field_values = self.fields.get(field_name, [])
                    field_values.append(value)
                    self.fields[field_name] = field_values

    def handle_data(self, data):
        if data.strip() and len(self.fields) > 0:
            field_name = next(reversed(self.fields))
            field_values = self.fields[field_name]
            field_values.append(data.strip())
            self.fields[field_name] = field_values


class PlayerBot(Bot):

    cases = list(range(0, 0))

    def play_round_man(self):
        p =Player()

        yield (pages.Past, {'influence_society':p.choice_past_list[0][0],
                            'influence_like_you':p.choice_past_list[0][0],
                            'open_ended_past':p.choice_past_list[0][0]})
        yield (pages.Future, {'future_like_you': p.choice_future_list[0][0],
                            'future_influence_society': p.choice_future_list[0][0],
                            'open_ended_future': "bots test"})

        yield (pages.Changes, {'changes': p.choice_support_list[0][0]})

        yield (pages.Changes_specifics, {'change_override': p.choice_support_list[0][0],
                              'change_selection': p.choice_support_list[0][0],
                              'change_reasonable':  p.choice_support_list[0][0]})

    def play_round(self):
        p = self.player
        choices_list = {'influence_society': p.choice_past_list[0],
                       'influence_like_you': p.choice_past_list[0],
                       'open_ended_past': p.choice_past_list[0],
                       'future_like_you': p.choice_future_list[0],
                       'future_influence_society': p.choice_future_list[0],
                       'open_ended_future': ["bots test"],
                       'changes': p.choice_support_list[0],
                       'change_override': p.choice_support_list[0],
                       'change_selection': p.choice_support_list[0],
                       'change_reasonable': p.choice_support_list[0],
                        'specific_decision_quality':p.choice_decision_quality}
        print (f"number of pages {len(pages.page_sequence)}")
        for page in pages.page_sequence[0:min(len(pages.page_sequence),self.case)]:
            dform = {field_name: self.form_for_case(field_name, 0, choices_list) for field_name in page.form_fields if
                     field_name != 'specific_decision_quality' or p.specific_decision != 'CG'}
            print("##############################")
            yield (page, dform)

            # Create an instance of the parser
            parser = MyHTMLParser()
            myhtml= str(self.html)
            # Parse the HTML content
            parser.feed(myhtml)

            dform = {field_name: self.form_for_case(field_name, 0, field_values) for field_name, field_values in parser.fields.items()}


            print(dform)

    def form_for_case(self, field_name, i, choice_list):
        if field_name in choice_list:
            return choice_list[field_name][i % len(choice_list[field_name])]
        else:
            return '0'