from datetime import timedelta
from typing import Union

from .transition_type import TransitionType


class Transition:

    def __init__(self,
                 at,       # type: int
                 ttype,    # type: TransitionType
                 previous  # type: Union['Transition', None]
                 ):
        self._at = at

        if previous:
            self._local = at + previous.ttype.offset
        else:
            self._local = at + ttype.offset

        self._ttype = ttype
        self._previous = previous

        if self.previous:
            self._fix = self._ttype.offset - self.previous.ttype.offset
        else:
            self._fix = 0

        self._to = self._local + self._fix
        self._to_utc = self._at + self._fix
        self._utcoffset = timedelta(seconds=ttype.offset)

    @property
    def at(self):  # type: () -> int
        return self._at

    @property
    def local(self):  # type: () -> int
        return self._local
    
    @property
    def to(self):  # type: () -> int
        return self._to

    @property
    def to_utc(self):  # type: () -> int
        return self._to

    @property
    def ttype(self):  # type: () -> TransitionType
        return self._ttype

    @property
    def previous(self):  # type: () -> Transition
        return self._previous

    @property
    def fix(self):  # type: () -> int
        return self._fix

    def is_ambiguous(self, stamp):  # type: (int) -> bool
        return self._to <= stamp < self._local

    def is_missing(self, stamp):  # type: (int) -> bool
        return self._local <= stamp < self._to

    def utcoffset(self):  # type: () -> timedelta
        return self._utcoffset

    def __contains__(self, stamp):  # type: () -> bool
        return self.previous.local <= stamp < self.local

    def __repr__(self):  # type: () -> str
        return 'Transition({} -> {}, {})'.format(
            self._local, self._to, self._ttype
        )
