# coding: utf-8
import asyncio
import configparser
import datetime
import os
import sys
import uuid
import pytest

import aiohttp
from wallabag_api.wallabag import Wallabag

ROOT_DIR = os.path.dirname(os.path.abspath(__file__))
CONFIG_PATH = os.path.join(ROOT_DIR, "testcfg.ini")


def load_test_config(path):
    config = configparser.ConfigParser()
    config.read(path)
    return config["Test Configuration"]


class TestWallabag:
    entry_data = {
        "title": "foobar title",
        "url": "https://somwhere.over.the.raibow.com/",
        "tags": ["foo", "bar"],
        "starred": 0,
        "archive": 0,
        "content": "<p>Additional content</p>",
        "language": "FR",
        "published_at": datetime.datetime.now(),
        "authors": "John Doe",
        "public": 0,
        "original_url": "http://localhost",
    }

    @pytest.fixture(scope="function")
    async def configuration(self):
        return load_test_config(CONFIG_PATH)

    @pytest.fixture(scope="function")
    async def setup_class(self, configuration):
        access_token = await Wallabag.get_token(**configuration)
        async with aiohttp.ClientSession() as session:
            wallabag = Wallabag(
                host=configuration["host"],
                token=access_token,
                client_id=configuration["client_id"],
                client_secret=configuration["client_secret"],
                aio_sess=session,
            )
            entry = await wallabag.post_entries(**self.entry_data)
            yield wallabag, entry
            await wallabag.delete_entries(entry["id"])

    @pytest.mark.asyncio
    async def test_get_token(self, configuration):
        data = await Wallabag.get_token(**configuration)
        print(data, file=sys.stderr)
        assert isinstance(data, str)

    @pytest.mark.asyncio
    async def test_get_entries(self, setup_class):
        wallabag, _ = setup_class
        data = await wallabag.get_entries(
            **{
                "delete": 0,
                "sort": "created",
                "order": "desc",
                "page": 1,
                "perPage": 30,
                "tags": [],
            }
        )
        assert isinstance(data, dict)

    @pytest.mark.asyncio
    async def test_get_entries_non_existing_page(self, setup_class):
        wallabag, _ = setup_class
        data = await wallabag.get_entries(
            **{
                "delete": 0,
                "sort": "created",
                "order": "desc",
                "page": 10,
                "perPage": 30,
                "tags": [],
            }
        )
        assert isinstance(data, dict)

    @pytest.mark.asyncio
    async def test_get_entry(self, setup_class):
        wallabag, entry = setup_class
        entry_id = entry["id"]
        assert isinstance(entry_id, int)
        data = await wallabag.get_entry(entry_id)
        assert isinstance(data, dict)

    @pytest.mark.asyncio
    async def test_get_entry_tags(self, setup_class):
        wallabag, entry = setup_class
        entry_id = entry["id"]
        assert isinstance(entry_id, int)
        data = await wallabag.get_entry_tags(entry_id)
        tag_names = [t["label"] for t in data]
        assert isinstance(data, list)
        assert self.entry_data["tags"] == tag_names

    @pytest.mark.asyncio
    async def test_get_tags(self, setup_class):
        wallabag, _ = setup_class
        data = await wallabag.get_tags()
        assert isinstance(data, list)

    @pytest.mark.asyncio
    async def test_post_entries(self, setup_class):
        wallabag, _ = setup_class
        entry_data = self.entry_data.copy()
        entry_data["url"] = "https://example.org"
        data = await wallabag.post_entries(**entry_data)
        assert data
        assert isinstance(data["id"], int)
        await wallabag.delete_entries(data["id"])

    @pytest.mark.asyncio
    async def test_patch_entries(self, setup_class):
        wallabag, entry = setup_class
        entry_id = entry["id"]
        assert isinstance(entry_id, int)
        data = await wallabag.patch_entries(
            entry_id,
            **{
                "title": "I change the title",
                "archive": 0,
                "tags": ["bimbo", "pipo"],
                "order": "asc",
                "star": 0,
                "delete": 0,
            },
        )
        assert data

    @pytest.mark.asyncio
    async def test_delete_entries(self, setup_class):
        wallabag, _ = setup_class
        entry_id = await self._create_entry(wallabag)
        assert isinstance(entry_id, int)
        data = await wallabag.delete_entries(entry_id)
        assert data

    @pytest.mark.asyncio
    async def test_post_entry_tags(self, setup_class):
        wallabag, entry = setup_class
        entry_id = entry["id"]
        assert isinstance(entry_id, int)
        tags = ["foo", "bar"]
        assert isinstance(tags, list)
        data = await wallabag.post_entry_tags(entry_id, tags)
        assert data

    @pytest.mark.asyncio
    async def test_delete_entry_tag(self, setup_class):
        wallabag, _ = setup_class
        entry_id = await self._create_entry(wallabag)
        tag_id = 1
        assert isinstance(entry_id, int)
        assert isinstance(tag_id, int)
        resp = await wallabag.delete_entry_tag(entry_id, tag_id)
        assert isinstance(resp["tags"], list)
        resp_tags_id = [t["id"] for t in resp["tags"]]
        assert len(resp_tags_id) == 1
        assert tag_id not in resp_tags_id
        await self._delete_entry(wallabag, entry_id)

    @pytest.mark.asyncio
    async def test_put_annotations(self, setup_class):
        wallabag, entry = setup_class
        entry_id = entry["id"]
        annotation = await wallabag.post_annotations(
            entry_id,
            ranges=[
                {"start": "/p[1]", "startOffset": 0, "end": "/p[1]", "endOffset": 10}
            ],
            quote="test quote",
            text="test annotation",
        )
        annotation_id = annotation["id"]
        data = await wallabag.put_annotations(annotation_id)
        assert data is not None

    @pytest.mark.asyncio
    async def test_reload_entry(self, setup_class):
        wallabag, entry = setup_class
        entry_id = entry["id"]
        assert isinstance(entry_id, int)
        try:
            data = await wallabag.patch_entry_reload(entry_id)
            assert data
        except Exception as e:
            if "304" in str(e):
                pass
            else:
                raise

    @pytest.mark.asyncio
    async def test_entries_exists(self, setup_class):
        wallabag, entry = setup_class
        entry_url = entry["url"]
        data = await wallabag.entries_exists(url=entry_url)
        if isinstance(data, dict) and "exists" in data:
            assert data["exists"] is True
        data = await wallabag.entries_exists(url="https://nonexistent.example.com")
        if isinstance(data, dict) and "exists" in data:
            assert data["exists"] is False

    @pytest.mark.asyncio
    async def test_delete_tag(self, setup_class):
        wallabag, entry = setup_class
        entry_id = entry["id"]
        tags = ["tag_for_deletion"]
        await wallabag.post_entry_tags(entry_id, tags)
        all_tags = await wallabag.get_tags()
        tag_to_delete = next(
            (t for t in all_tags if t["label"] == "tag_for_deletion"), None
        )
        if tag_to_delete:
            data = await wallabag.delete_tag(tag_to_delete["id"])
            assert data

    @pytest.mark.asyncio
    async def test_delete_tag_label(self, setup_class):
        wallabag, entry = setup_class
        entry_id = entry["id"]
        tags = ["label_for_deletion"]
        await wallabag.post_entry_tags(entry_id, tags)
        data = await wallabag.delete_tag_label("label_for_deletion")
        assert data

    @pytest.mark.asyncio
    async def test_delete_tags_label(self, setup_class):
        wallabag, entry = setup_class
        entry_id = entry["id"]
        tags = ["multi_delete_1", "multi_delete_2"]
        await wallabag.post_entry_tags(entry_id, tags)
        data = await wallabag.delete_tags_label(tags)
        assert data is not None

    @pytest.mark.asyncio
    async def test_get_annotations(self, setup_class):
        wallabag, entry = setup_class
        entry_id = entry["id"]
        data = await wallabag.get_annotations(entry_id)
        assert isinstance(data, (dict, list))
        if isinstance(data, dict):
            assert "rows" in data or "total" in data

    @pytest.mark.asyncio
    async def test_post_annotations(self, setup_class):
        wallabag, entry = setup_class
        entry_id = entry["id"]
        data = await wallabag.post_annotations(
            entry_id,
            ranges=[
                {"start": "/p[1]", "startOffset": 0, "end": "/p[1]", "endOffset": 10}
            ],
            quote="test quote",
            text="test annotation",
        )
        assert data
        assert "id" in data
        return data["id"]

    @pytest.mark.asyncio
    async def test_put_annotations(self, setup_class):
        wallabag, entry = setup_class
        entry_id = entry["id"]
        annotation = await wallabag.post_annotations(
            entry_id,
            ranges=[
                {"start": "/p[1]", "startOffset": 0, "end": "/p[1]", "endOffset": 10}
            ],
            quote="test quote",
            text="test annotation",
        )
        annotation_id = annotation["id"]
        data = await wallabag.put_annotations(annotation_id)
        assert data is not None

    @pytest.mark.asyncio
    async def test_delete_annotations(self, setup_class):
        wallabag, entry = setup_class
        entry_id = entry["id"]
        annotation = await wallabag.post_annotations(
            entry_id,
            ranges=[
                {"start": "/p[1]", "startOffset": 0, "end": "/p[1]", "endOffset": 10}
            ],
            quote="test quote",
            text="test annotation",
        )
        annotation_id = annotation["id"]
        data = await wallabag.delete_annotations(annotation_id)
        assert data

    @pytest.mark.asyncio
    async def test_version(self, setup_class):
        wallabag, _ = setup_class
        data = await wallabag.version
        assert data

    async def _create_entry(self, wallabag):
        data = self.entry_data.copy()
        data["title"] = "Some title 2"
        data["url"] = f"https://somwhere.over.the.raibow.com/{uuid.uuid4()}"
        entry = await wallabag.post_entries(**data)
        assert isinstance(entry["id"], int)
        return entry["id"]

    async def _delete_entry(self, wallabag, entry_id):
        await wallabag.delete_entries(entry_id)