from validator import Validator, fields, FieldValidationError
from normalutils.choices import WordPropertyType

from models import Word, Meaning, Session


class WordAddSerializer(Validator):
    spelling = fields.StringField(1, 64, allow_null=False)
    importance = fields.StringField(required=False)

    def __init__(self, raw_data, session: Session, *args, **kwargs):
        super().__init__(raw_data)
        self.__session = session

    def save(self):
        assert self.errors == {}
        return self.create(self.validated_data)

    def create(self, data):
        session = self.__session
        word = Word(**data)
        session.add(word)
        return word


class MeaningAddSerializer(Validator):
    meaning = fields.StringField()
    word_property = fields.StringField()
    sentence = fields.StringField(required=False)

    def __init__(self, raw_data, session: Session, word, *args, **kwargs):
        super().__init__(raw_data)
        self.__session = session
        self.__word = word

    def validate_word_property(self, data):
        try:
            WordPropertyType.is_valid(data, True)
        except Exception as e:
            raise FieldValidationError(e)

    def save(self):
        assert self.errors == {}
        return self.create(self.validated_data)

    def create(self, data):
        session = self.__session
        meaning = Meaning(word=self.__word, **data)
        session.add(meaning)
        return meaning


def testcase1():
    data = {
        "spelling": "a",
        "meaning": "haha",
        "word_property": "n."
    }
    with Session() as session:
        serializer = WordAddSerializer(data, session)
        serializer.is_valid()
        serializer.save()
        session.commit()


if __name__ == "__main__":
    data = {'spelling': "None", 'importance': None}
    with Session() as session:
        serializer = WordAddSerializer(data, session)
        flag = serializer.is_valid()
    print(serializer.validated_data)