# SPDX-License-Identifier: GPL-3.0-or-later

# Haketilo proxy data and configuration (MappingRef and MappingStore subtypes).
#
# This file is part of Hydrilla&Haketilo.
#
# Copyright (C) 2022 Wojtek Kosior
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see <https://www.gnu.org/licenses/>.
#
#
# I, Wojtek Kosior, thereby promise not to sue for violation of this
# file's license. Although I request that you do not make use this code
# in a proprietary program, I am not going to enforce this in court.

"""
This module provides an interface to interact with mappings inside Haketilo.
"""

# Enable using with Python 3.7.
from __future__ import annotations

import io
import typing as t
import dataclasses as dc

from ... import item_infos
from .. import state as st
from . import base


@dc.dataclass(frozen=True, unsafe_hash=True)
class ConcreteMappingVersionRef(st.MappingVersionRef):
    """...."""
    state: base.HaketiloStateWithFields = dc.field(hash=False, compare=False)

    def update_status(self, new_status: st.EnabledStatus) -> None:
        """...."""
        assert new_status != st.EnabledStatus.AUTO_ENABLED
        raise NotImplementedError()

    def get_display_info(self) -> st.MappingDisplayInfo:
        with self.state.cursor() as cursor:
            cursor.execute(
                '''
                SELECT
                        enabled,
                        definition,
                        repo,
                        repo_iteration,
                        is_orphan
                FROM
                        mapping_display_infos
                WHERE
                        item_version_id = ?;
                ''',
                (self.id,)
            )

            rows = cursor.fetchall()

        if rows == []:
            raise st.MissingItemError()

        (status_letter, definition, repo, repo_iteration, is_orphan), = rows

        item_info = item_infos.MappingInfo.load(
            definition,
            repo,
            repo_iteration
        )

        status = st.EnabledStatus(status_letter)

        return st.MappingDisplayInfo(self, item_info, status, is_orphan)


@dc.dataclass(frozen=True)
class ConcreteMappingVersionStore(st.MappingVersionStore):
    state: base.HaketiloStateWithFields

    def get(self, id: str) -> st.MappingVersionRef:
        return ConcreteMappingVersionRef(id, self.state)

    def get_display_infos(self) -> t.Iterable[st.MappingDisplayInfo]:
        with self.state.cursor() as cursor:
            cursor.execute(
                '''
                SELECT
                        enabled,
                        item_version_id,
                        definition,
                        repo,
                        repo_iteration,
                        is_orphan
                FROM
                        mapping_display_infos;
                '''
            )

            all_rows = cursor.fetchall()

        result = []

        for row in all_rows:
            (status_letter, item_version_id, definition, repo, repo_iteration,
             is_orphan) = row

            ref = ConcreteMappingVersionRef(str(item_version_id), self.state)

            item_info = item_infos.MappingInfo.load(
                definition,
                repo,
                repo_iteration
            )

            status = st.EnabledStatus(status_letter)

            info = st.MappingDisplayInfo(ref, item_info, status, is_orphan)
            result.append(info)

        return sorted(result, key=(lambda di: di.info))