import src.forms.exceptions as forms_exceptions
import src.forms.service as service
import src.messages as messages
import tests.factories.forms as form_factory
from fastapi.exceptions import HTTPException
from src import models
from src.auth.auth import get_current_user
from src.main import app


class TestForms:
    def test_get_all(self, client, mocker, mock_session, mock_user):
        mock_results = [
            form_factory.form_public_factory(name="test 1", id=1),
            form_factory.form_public_factory(name="test 2", id=2),
            form_factory.form_public_factory(name="test 3", id=3),
        ]
        mock = mocker.patch.object(
            service,
            'get_all',
            return_value=mock_results
        )

        response = client.get('/api/forms/referents')
        response_data = response.json()
        assert response.status_code == 200
        assert response_data[0]['id'] == 1
        assert len(response_data) == len(mock_results)
        mock.assert_called_once_with(
            mock_session,
            [],
            [],
            False,
            mock_user,
        )

    def test_get_all_filters(self, client, mocker, mock_session, mock_user):
        mock_results = [
            form_factory.form_public_factory(name="test 2", id=2),
        ]
        mock = mocker.patch.object(
            service,
            'get_all',
            return_value=mock_results
        )

        response = client.get(
            '/api/forms/referents?current_season=true&seasons=hiver-2025&productors=test productor')
        response_data = response.json()
        assert response.status_code == 200
        assert response_data[0]['id'] == 2
        assert len(response_data) == len(mock_results)
        mock.assert_called_once_with(
            mock_session,
            ['hiver-2025'],
            ['test productor'],
            True,
            mock_user,
        )

    def test_get_all_unauthorized(
            self,
            client,
            mocker,
            mock_session,
            mock_user):
        def unauthorized():
            raise HTTPException(status_code=401)

        app.dependency_overrides[get_current_user] = unauthorized

        mock = mocker.patch('src.forms.service.get_all')
        response = client.get('/api/forms/referents')

        assert response.status_code == 401
        mock.assert_not_called()

        app.dependency_overrides.clear()

    def test_get_one(self, client, mocker, mock_session, mock_user):
        mock_result = form_factory.form_public_factory(name="test 2", id=2)

        mock = mocker.patch.object(
            service,
            'get_one',
            return_value=mock_result
        )

        response = client.get('/api/forms/2')
        response_data = response.json()

        assert response.status_code == 200
        assert response_data['id'] == 2
        mock.assert_called_once_with(
            mock_session,
            2
        )

    def test_get_one_notfound(self, client, mocker, mock_session, mock_user):
        mock_result = None
        mock = mocker.patch.object(
            service,
            'get_one',
            return_value=mock_result
        )
        response = client.get('/api/forms/2')
        response_data = response.json()
        assert response.status_code == 404
        mock.assert_called_once_with(
            mock_session,
            2
        )

    def test_create_one(self, client, mocker, mock_session, mock_user):
        form_body = form_factory.form_body_factory(name='test form create')
        form_create = form_factory.form_create_factory(name='test form create')
        form_result = form_factory.form_public_factory(name='test form create')

        mock = mocker.patch.object(
            service,
            'create_one',
            return_value=form_result
        )

        response = client.post('/api/forms', json=form_body)
        response_data = response.json()

        assert response.status_code == 200
        assert response_data['name'] == 'test form create'
        mock.assert_called_once_with(
            mock_session,
            form_create
        )

    def test_create_one_referer_notfound(
            self, client, mocker, mock_session, mock_user):
        form_body = form_factory.form_body_factory(
            name='test form create', referer_id=12312)
        form_create = form_factory.form_create_factory(
            name='test form create', referer_id=12312)

        mock = mocker.patch.object(
            service, 'create_one', side_effect=forms_exceptions.UserNotFoundError(
                messages.Messages.not_found('referer')))

        response = client.post('/api/forms', json=form_body)
        response_data = response.json()

        assert response.status_code == 404
        mock.assert_called_once_with(
            mock_session,
            form_create
        )

    def test_create_one_productor_notfound(
            self, client, mocker, mock_session, mock_user):
        form_body = form_factory.form_body_factory(
            name='test form create', productor_id=1231)
        form_create = form_factory.form_create_factory(
            name='test form create', productor_id=1231)

        mock = mocker.patch.object(
            service, 'create_one', side_effect=forms_exceptions.ProductorNotFoundError(
                messages.Messages.not_found('productor')))

        response = client.post('/api/forms', json=form_body)
        response_data = response.json()

        assert response.status_code == 404
        mock.assert_called_once_with(
            mock_session,
            form_create
        )

    def test_create_one_unauthorized(
            self,
            client,
            mocker,
            mock_session,
            mock_user):
        def unauthorized():
            raise HTTPException(status_code=401)
        form_body = form_factory.form_body_factory(name='test form create')

        app.dependency_overrides[get_current_user] = unauthorized

        mock = mocker.patch('src.forms.service.create_one')
        response = client.post('/api/forms', json=form_body)

        assert response.status_code == 401
        mock.assert_not_called()

        app.dependency_overrides.clear()

    def test_update_one(self, client, mocker, mock_session, mock_user):
        form_body = form_factory.form_body_factory(name='test form update')
        form_update = form_factory.form_update_factory(name='test form update')
        form_result = form_factory.form_public_factory(name='test form update')

        mock = mocker.patch.object(
            service,
            'update_one',
            return_value=form_result
        )

        response = client.put('/api/forms/2', json=form_body)
        response_data = response.json()

        assert response.status_code == 200
        assert response_data['name'] == 'test form update'
        mock.assert_called_once_with(
            mock_session,
            2,
            form_update
        )

    def test_update_one_notfound(
            self,
            client,
            mocker,
            mock_session,
            mock_user):
        form_body = form_factory.form_body_factory(name='test form update')
        form_update = form_factory.form_update_factory(name='test form update')

        mock = mocker.patch.object(
            service, 'update_one', side_effect=forms_exceptions.FormNotFoundError(
                messages.Messages.not_found('form')))

        response = client.put('/api/forms/2', json=form_body)
        response_data = response.json()

        assert response.status_code == 404
        mock.assert_called_once_with(
            mock_session,
            2,
            form_update
        )

    def test_update_one_referer_notfound(
            self, client, mocker, mock_session, mock_user):
        form_body = form_factory.form_body_factory(name='test form update')
        form_update = form_factory.form_update_factory(name='test form update')

        mock = mocker.patch.object(
            service, 'update_one', side_effect=forms_exceptions.UserNotFoundError(
                messages.Messages.not_found('referer')))

        response = client.put('/api/forms/2', json=form_body)
        response_data = response.json()

        assert response.status_code == 404
        mock.assert_called_once_with(
            mock_session,
            2,
            form_update
        )

    def test_update_one_productor_notfound(
            self, client, mocker, mock_session, mock_user):
        form_body = form_factory.form_body_factory(name='test form update')
        form_update = form_factory.form_update_factory(name='test form update')

        mock = mocker.patch.object(
            service, 'update_one', side_effect=forms_exceptions.ProductorNotFoundError(
                messages.Messages.not_found('productor')))

        response = client.put('/api/forms/2', json=form_body)
        response_data = response.json()

        assert response.status_code == 404
        mock.assert_called_once_with(
            mock_session,
            2,
            form_update
        )

    def test_update_one_unauthorized(
            self,
            client,
            mocker,
            mock_session,
            mock_user):
        def unauthorized():
            raise HTTPException(status_code=401)
        form_body = form_factory.form_body_factory(name='test form update')

        app.dependency_overrides[get_current_user] = unauthorized

        mock = mocker.patch('src.forms.service.update_one')
        response = client.put('/api/forms/2', json=form_body)

        assert response.status_code == 401
        mock.assert_not_called()

        app.dependency_overrides.clear()

    def test_delete_one(self, client, mocker, mock_session, mock_user):
        form_result = form_factory.form_public_factory(name='test form delete')

        mock = mocker.patch.object(
            service,
            'delete_one',
            return_value=form_result
        )

        response = client.delete('/api/forms/2')
        response_data = response.json()

        assert response.status_code == 200
        assert response_data['name'] == 'test form delete'
        mock.assert_called_once_with(
            mock_session,
            2,
        )

    def test_delete_one_notfound(
            self,
            client,
            mocker,
            mock_session,
            mock_user):
        form_result = None

        mock = mocker.patch.object(
            service, 'delete_one', side_effect=forms_exceptions.FormNotFoundError(
                messages.Messages.not_found('form')))

        response = client.delete('/api/forms/2')
        response_data = response.json()

        assert response.status_code == 404
        mock.assert_called_once_with(
            mock_session,
            2,
        )

    def test_delete_one_unauthorized(
            self,
            client,
            mocker,
            mock_session,
            mock_user):
        def unauthorized():
            raise HTTPException(status_code=401)

        app.dependency_overrides[get_current_user] = unauthorized

        mock = mocker.patch('src.forms.service.delete_one')
        response = client.delete('/api/forms/2')

        assert response.status_code == 401
        mock.assert_not_called()

        app.dependency_overrides.clear()