from .text_utils import split_words
from .stream import StreamInstanceOperator, InstanceOperatorWithGlobalAccess, Artifact

from datasets import Value, Features, Dataset, Sequence

from dataclasses import field
from typing import Dict, Any
from abc import ABC, abstractmethod

class Validator(ABC):
    pass

class ValidateSchema(Validator, StreamInstanceOperator):
    
    schema: Features = None
    
    def verify(self):
        assert isinstance(self.schema, Features), 'Schema must be an instance of Features'
        assert self.schema is not None, 'Schema must be specified'
    
    def verify_first_instance(self, instance):
        for field in self.standart_fields:
            assert field in instance, f'Field "{field}" is missing in the first instance'
    
    def process(self, instance: Dict[str, Any], stream_name: str = None) -> Dict[str, Any]:
        return instance

class StandardSchema(Features):
    
    def __init__(self):
        super().__init__({
            'source': Value('string'),
            'target': Value('string'),
            'references': Sequence(Value('string')),
            'metrics': Sequence(Value('string')),
            'parser': Value('string'),
            # 'group': Value('string'),
            # 'guidance': Value('string'),
        })

class ValidateStandartSchema:
    
    schema: Features = field(default_factory=StandardSchema)