import assert from 'assert';
import { app } from '../../../src/app';
import * as sinon from 'sinon';
import config from 'config';
import { faker } from '@faker-js/faker';
import wildDuckClient from '../../../src/clients/wildduck.client';

describe('aliases service', () => {
    let sandbox: sinon.SinonSandbox;

    beforeEach(() => {
        sandbox = sinon.createSandbox();
    });

    afterEach(() => {
        sandbox.restore();
    });

    it('registered the service', () => {
        const service = app.service('aliases');

        assert.ok(service, 'Registered the service');
    });

    it('creates a new alias successfully', async () => {
        const service = app.service('aliases');

        const configGetStub = sandbox.stub(config, 'get');
        configGetStub.withArgs('wildDuck.domain').returns('example.com');
        configGetStub.withArgs('wildDuck.preferredDomain').returns('example.com');

        sandbox.stub(faker.git, 'commitSha').returns('abcd');
        sandbox.stub(faker.color, 'human').returns('red');
        sandbox.stub(faker.animal, 'snake').returns('snake');

        sandbox.stub(wildDuckClient, 'get').callsFake((url: string) => {
            if (url === 'addresses/resolve/user@example.com') {
                return Promise.resolve({
                    data: {
                        success: true,
                        user: 'user123',
                        id: 'addr123',
                        address: 'user@example.com',
                        main: true,
                        tags: [],
                        created: '2025-01-01',
                    },
                });
            }
            if (url === '/users/user123/addresses') {
                return Promise.resolve({
                    data: {
                        success: true,
                        results: [
                            {
                                success: true,
                                id: 'alias456',
                                address: 'red-snake-abcd@example.com',
                                main: false,
                                user: 'user123',
                                tags: ['test'],
                                created: '2025-12-09T10:00:00Z',
                            },
                        ],
                    },
                });
            }
            return Promise.reject(new Error(`Unexpected URL: ${url}`));
        });

        sandbox.stub(wildDuckClient, 'post').resolves({
            data: {
                success: true,
                id: 'alias456',
            },
        });

        const params = {
            session: {
                user: {
                    emails: ['user@example.com'],
                },
            },
        };

        const data = { tags: ['test'] };

        const result = await service.create(data, params);

        assert.ok(Array.isArray(result), 'Result should be an array');
        assert.strictEqual(result.length, 1, 'Result should contain one alias');
        assert.strictEqual(
            result[0].address,
            'red-snake-abcd@example.com',
            'Alias should have the expected address'
        );
        assert.deepStrictEqual(result[0].tags, ['test'], 'Alias should have the correct tags');
        assert.ok(result[0].created, 'Alias should have a created date');
        assert.strictEqual(result[0].id, 'alias456', 'Removable alias should have an id');
    });

    it('finds user aliases successfully', async () => {
        const service = app.service('aliases');

        const configGetStub = sandbox.stub(config, 'get');
        configGetStub.withArgs('wildDuck.domain').returns('example.com');
        configGetStub.withArgs('wildDuck.preferredDomain').returns('example.com');

        sandbox.stub(wildDuckClient, 'get').callsFake((url: string) => {
            if (url === 'addresses/resolve/user@example.com') {
                return Promise.resolve({
                    data: {
                        success: true,
                        user: 'user123',
                        id: 'addr123',
                        address: 'user@example.com',
                        main: true,
                        tags: [],
                        created: '2025-01-01',
                    },
                });
            }
            if (url === '/users/user123/addresses') {
                return Promise.resolve({
                    data: {
                        success: true,
                        results: [
                            {
                                success: true,
                                id: 'alias456',
                                address: 'red-snake-abcd@example.com',
                                main: false,
                                user: 'user123',
                                tags: ['test'],
                                created: '2025-12-09T10:00:00Z',
                            },
                            {
                                success: true,
                                id: null,
                                address: 'user@example.com',
                                main: true,
                                user: 'user123',
                                tags: [],
                                created: '2025-01-01',
                            },
                        ],
                    },
                });
            }
            return Promise.reject(new Error(`Unexpected URL: ${url}`));
        });

        const params = {
            session: {
                user: {
                    emails: ['user@example.com'],
                },
            },
        };

        const result = await service.find(params);

        assert.ok(Array.isArray(result), 'Result should be an array');
        assert.strictEqual(result.length, 2, 'Result should contain two aliases');
        assert.strictEqual(result[0].address, 'red-snake-abcd@example.com', 'First alias address');
        assert.strictEqual(result[0].id, 'alias456', 'Removable alias has id');
        assert.strictEqual(result[1].address, 'user@example.com', 'Second alias address');
        assert.strictEqual(result[1].id, null, 'Main alias has no id');
    });

    it('removes an alias successfully', async () => {
        const service = app.service('aliases');

        const configGetStub = sandbox.stub(config, 'get');
        configGetStub.withArgs('wildDuck.domain').returns('example.com');
        configGetStub.withArgs('wildDuck.preferredDomain').returns('example.com');

        sandbox.stub(wildDuckClient, 'get').callsFake((url: string) => {
            if (url === 'addresses/resolve/user@example.com') {
                return Promise.resolve({
                    data: {
                        success: true,
                        user: 'user123',
                        id: 'addr123',
                        address: 'user@example.com',
                        main: true,
                        tags: [],
                        created: '2025-01-01',
                    },
                });
            }
            if (url === 'addresses/resolve/alias456') {
                return Promise.resolve({
                    data: {
                        success: true,
                        id: 'alias456',
                        address: 'red-snake-abcd@example.com',
                        main: false,
                        user: 'user123',
                        tags: ['test'],
                        created: '2025-12-09T10:00:00Z',
                    },
                });
            }
            if (url === '/users/user123/addresses') {
                return Promise.resolve({
                    data: {
                        success: true,
                        results: [],
                    },
                });
            }
            return Promise.reject(new Error(`Unexpected URL: ${url}`));
        });

        sandbox.stub(wildDuckClient, 'delete').resolves({
            data: {
                success: true,
            },
        });

        const params = {
            session: {
                user: {
                    emails: ['user@example.com'],
                },
            },
        };

        const result = await service.remove('alias456', params);

        assert.ok(Array.isArray(result), 'Result should be an array');
        assert.strictEqual(result.length, 0, 'Result should be empty after deletion');
    });

    it('throws error when creating alias fails', async () => {
        const service = app.service('aliases');

        const configGetStub = sandbox.stub(config, 'get');
        configGetStub.withArgs('wildDuck.domain').returns('example.com');
        configGetStub.withArgs('wildDuck.preferredDomain').returns('example.com');

        sandbox.stub(faker.git, 'commitSha').returns('abcd');
        sandbox.stub(faker.color, 'human').returns('red');
        sandbox.stub(faker.animal, 'snake').returns('snake');

        sandbox.stub(wildDuckClient, 'get').callsFake((url: string) => {
            if (url === 'addresses/resolve/user@example.com') {
                return Promise.resolve({
                    data: {
                        success: true,
                        user: 'user123',
                        id: 'addr123',
                        address: 'user@example.com',
                        main: true,
                        tags: [],
                        created: '2025-01-01',
                    },
                });
            }
            return Promise.reject(new Error(`Unexpected URL: ${url}`));
        });

        sandbox.stub(wildDuckClient, 'post').resolves({
            data: {
                success: false,
            },
        });

        const params = {
            session: {
                user: {
                    emails: ['user@example.com'],
                },
            },
        };

        const data = { tags: ['test'] };

        try {
            await service.create(data, params);
            assert.fail('Should have thrown an error');
        } catch (error: any) {
            assert.strictEqual(error.message, 'Failed to create alias');
        }
    });

    it('throws error when removing alias with invalid domain', async () => {
        const service = app.service('aliases');

        const configGetStub = sandbox.stub(config, 'get');
        configGetStub.withArgs('wildDuck.domain').returns('example.com');
        configGetStub.withArgs('wildDuck.preferredDomain').returns('example.com');

        sandbox.stub(wildDuckClient, 'get').callsFake((url: string) => {
            if (url === 'addresses/resolve/user@example.com') {
                return Promise.resolve({
                    data: {
                        success: true,
                        user: 'user123',
                        id: 'addr123',
                        address: 'user@example.com',
                        main: true,
                        tags: [],
                        created: '2025-01-01',
                    },
                });
            }
            if (url === 'addresses/resolve/alias456') {
                return Promise.resolve({
                    data: {
                        success: true,
                        id: 'alias456',
                        address: 'red-snake-abcd@invalid.com',
                        main: false,
                        user: 'user123',
                        tags: ['test'],
                        created: '2025-12-09T10:00:00Z',
                    },
                });
            }
            return Promise.reject(new Error(`Unexpected URL: ${url}`));
        });

        const params = {
            session: {
                user: {
                    emails: ['user@example.com'],
                },
            },
        };

        try {
            await service.remove('alias456', params);
            assert.fail('Should have thrown an error');
        } catch (error: any) {
            assert.strictEqual(error.message, 'Unable to delete address');
        }
    });
});