import pytest
import factory
from collections import namedtuple
from wtforms import Form, fields
from werkzeug.datastructures import ImmutableMultiDict
from pydantic_form import PydanticForm
from pydantic import BaseModel


ScenarioClasses = namedtuple(
    "ScenarioClasses",
    ['wtf_form', 'pydantic_form', 'schema', 'data_factory']
)

ScenarioInstances = namedtuple(
    "ScenarioInstances",
    [
        'wtf', 'wtf_formdata',
        'pydantic', 'pydantic_formdata',
        'formdata', 'data'
    ]
)


@pytest.fixture(scope="session")
def instance_factory():
    def _factory(scenario_classes, data):
        formdata = ImmutableMultiDict(data)
        return ScenarioInstances(
            scenario_classes.wtf_form(data=data),
            scenario_classes.wtf_form(formdata=formdata),
            scenario_classes.pydantic_form(data=data),
            scenario_classes.pydantic_form(formdata=formdata),
            formdata,
            data
        )
    return _factory


class SimpleSchema(BaseModel):
    integer: int
    string: str


class SimpleWTForm(Form):
    _schema = SimpleSchema

    integer = fields.IntegerField()
    string = fields.StringField()


class SimpleForm(SimpleWTForm, PydanticForm):
    _schema = SimpleSchema


@pytest.fixture(scope="session")
def scenario_classes_simple():
    return ScenarioClasses(SimpleWTForm, SimpleForm, SimpleSchema, SimpleDataFactory)


class SimpleDataFactory(factory.Factory):
    class Meta:
        model = dict

    integer = factory.Faker('pyint')
    string = factory.Faker('pystr')

class SimpleBadDataFactory(factory.Factory):
    class Meta:
        model = dict

    integer = factory.Faker('pystr')
    string = factory.Faker('pyint')


@pytest.fixture
def scenario_simple(instance_factory, scenario_classes_simple):
    return instance_factory(scenario_classes_simple, SimpleDataFactory())


@pytest.fixture
def scenario_simple_bad(instance_factory, scenario_classes_simple):
    return instance_factory(scenario_classes_simple, SimpleBadDataFactory())



class NestedSchema(BaseModel):
    integer: int
    nested: SimpleSchema


class NestedWTForm(Form):
    _schema = NestedSchema

    integer = fields.IntegerField()
    nested = fields.FormField(form_class=SimpleForm)


class NestedForm(NestedWTForm, PydanticForm):
    _schema = NestedSchema


class NestedDataFactory(factory.Factory):
    class Meta:
        model = dict

    integer = factory.Faker('pyint')
    nested = factory.SubFactory(SimpleDataFactory)


class NestedBadDataFactory(factory.Factory):
    class Meta:
        model = dict

    integer = factory.Faker('pystr')
    nested = factory.SubFactory(SimpleBadDataFactory)


@pytest.fixture(scope="session")
def scenario_classes_nested():
    return ScenarioClasses(NestedWTForm, NestedForm, NestedSchema, NestedDataFactory)


@pytest.fixture
def scenario_nested(instance_factory, scenario_classes_nested):
    return instance_factory(scenario_classes_nested, NestedDataFactory())


@pytest.fixture
def scenario_nested_bad(instance_factory, scenario_classes_nested):
    return instance_factory(scenario_classes_nested, NestedBadDataFactory())