import mimetypes
import os
from typing import Tuple, Optional


class ListGenerator:
    def __init__(self, path: str = None):
        self.path = path
        self.list: list = self._lister(self.path)
        self._size = len(self.list)
        self._current_index = 0

    def __str__(self) -> str:
        if self.path:
            return self.name
        else:
            return 'Audio iter generator'

    @property
    def name(self) -> str:
        return self.list[self._current_index]

    @classmethod
    def _lister(cls, path) -> list:
        _dict: list = []
        try:
            for _files in os.walk(path):
                _dict.extend(_files)
                break
            return _dict[2]
        except TypeError:
            pass

    def __iter__(self):
        return _ListGenerationIter(self)

    def __next__(self):
        if self._current_index < self._size:
            self._current_index += 1


class _FileAttrs:
    def __init__(self, name, path, type):
        self.name = name
        self.path = path
        self.type = type

    def __str__(self):
        return self.name

    def __repr__(self):
        return f'<File attrs name={self.name} path={self.path} type=<{self.type}> >'


class _ListGenerationIter:

    def __init__(self, list_class):
        self._current_index = 0
        self._list = list_class.list
        self._name = self._list[self._current_index]
        self._path = list_class.path

        self._size = len(self._list)

    def __iter__(self):
        return self

    @property
    def type(self) -> tuple[Optional[str], Optional[str]]:
        guess = mimetypes.guess_type(f'{self._path}/{self._list[self._current_index]}')[0]
        return guess

    def __next__(self):
        if self._current_index < self._size:
            _name = self._list[self._current_index]
            _path = self._path
            _type = self.type
            self._current_index += 1
            memb = _FileAttrs(_name, _path, _type)
            return memb
        raise StopIteration