from __future__ import annotations

import unittest

from sqlalchemy import create_engine, select
from sqlalchemy.orm import Session, sessionmaker

from govoplan_core.core.configuration_packages import (
    ConfigurationExportSelection,
    ConfigurationPackageFragment,
    ConfigurationPreflightContext,
)
from govoplan_core.db.base import Base
from govoplan_workflow_engine.backend.configuration_provider import (
    WORKFLOW_DEFINITIONS_FRAGMENT,
    apply_workflow_definitions,
    export_workflow_definitions,
    preflight_workflow_definitions,
)
from govoplan_workflow_engine.backend.db.models import (
    WorkflowDefinition,
    WorkflowDefinitionRevision,
)


def fragment(*, label: str = "Review request") -> ConfigurationPackageFragment:
    return ConfigurationPackageFragment(
        module_id="workflow_engine",
        fragment_type=WORKFLOW_DEFINITIONS_FRAGMENT,
        fragment_id="permit-workflows",
        payload={
            "origin_module_id": "permits",
            "origin_module_version": "1.0.0",
            "items": [
                {
                    "definition_key": "permit-review",
                    "name": "Permit review",
                    "scope_type": "system",
                    "graph": {
                        "schema_version": 1,
                        "nodes": [
                            {
                                "id": "start",
                                "type": "workflow.start.manual",
                                "label": "Start",
                                "config": {"input_schema_ref": ""},
                            },
                            {
                                "id": "review",
                                "type": "workflow.activity",
                                "label": label,
                                "config": {
                                    "title": label,
                                    "instructions": "",
                                    "assignee": "",
                                    "due_after": "",
                                },
                            },
                            {
                                "id": "done",
                                "type": "workflow.end.completed",
                                "label": "Done",
                                "config": {"output_mapping": {}},
                            },
                        ],
                        "edges": [
                            {
                                "id": "start-review",
                                "source": "start",
                                "target": "review",
                            },
                            {"id": "review-done", "source": "review", "target": "done"},
                        ],
                    },
                },
            ],
        },
    )


class WorkflowConfigurationProviderTests(unittest.TestCase):
    def setUp(self) -> None:
        self.engine = create_engine("sqlite:///:memory:")
        Base.metadata.create_all(
            self.engine,
            tables=[
                WorkflowDefinition.__table__,
                WorkflowDefinitionRevision.__table__,
            ],
        )
        self.Session = sessionmaker(bind=self.engine)
        self.session: Session = self.Session()
        self.context = ConfigurationPreflightContext(
            installed_modules={"workflow_engine": "0.1.14"},
        )

    def tearDown(self) -> None:
        self.session.close()
        Base.metadata.drop_all(
            self.engine,
            tables=[
                WorkflowDefinitionRevision.__table__,
                WorkflowDefinition.__table__,
            ],
        )
        self.engine.dispose()

    def test_fragment_preflight_apply_update_and_export(self) -> None:
        initial = preflight_workflow_definitions(
            self.session,
            fragment(),
            self.context,
        )
        created = apply_workflow_definitions(
            self.session,
            fragment(),
            self.context,
            registry=None,
        )
        repeated = apply_workflow_definitions(
            self.session,
            fragment(),
            self.context,
            registry=None,
        )
        updated = apply_workflow_definitions(
            self.session,
            fragment(label="Review corrected request"),
            self.context,
            registry=None,
        )
        exported = export_workflow_definitions(
            self.session,
            ConfigurationExportSelection(scopes=("system",)),
        )

        definition = self.session.scalar(select(WorkflowDefinition))
        assert definition is not None
        self.assertEqual("create", initial.plan[0].action)
        self.assertIn("permit-review", created.created_refs)
        self.assertFalse(repeated.created_refs)
        self.assertFalse(repeated.updated_refs)
        self.assertIn("permit-review", updated.updated_refs)
        self.assertEqual(2, definition.current_revision)
        self.assertEqual("workflow_definitions", exported.fragments[0].fragment_type)
        self.assertEqual(
            "permit-review",
            exported.fragments[0].payload["items"][0]["definition_key"],
        )


if __name__ == "__main__":
    unittest.main()