const should = require('should');
const sinon = require('sinon');
const urlUtils = require('../../../../core/shared/url-utils');
const urlService = require('../../../../core/frontend/services/url');
const getUrl = require('../../../../core/frontend/meta/url');
const testUtils = require('../../../utils');

describe('getUrl', function () {
    beforeEach(function () {
        sinon.stub(urlService, 'getUrlByResourceId');
        sinon.stub(urlUtils, 'urlFor');
    });

    afterEach(function () {
        sinon.restore();
    });

    it('should return url for a post', function () {
        const post = testUtils.DataGenerator.forKnex.createPost();

        urlService.getUrlByResourceId.withArgs(post.id, {absolute: undefined, secure: undefined, withSubdirectory: true})
            .returns('post url');

        getUrl(post).should.eql('post url');
    });

    describe('preview url: drafts/scheduled posts', function () {
        it('not absolute, not secure', function () {
            const post = testUtils.DataGenerator.forKnex.createPost({status: 'draft'});
            urlService.getUrlByResourceId.withArgs(post.id).returns('/404/');
            urlUtils.urlFor.withArgs({relativeUrl: '/p/' + post.uuid + '/', secure: undefined}, null, undefined).returns('relative');
            let url = getUrl(post);

            urlService.getUrlByResourceId.calledOnce.should.be.true();
            urlUtils.urlFor.withArgs({relativeUrl: '/p/' + post.uuid + '/', secure: undefined}, null, undefined)
                .calledOnce.should.be.true();

            url.should.eql('relative');
        });

        it('absolute, not secure', function () {
            const post = testUtils.DataGenerator.forKnex.createPost({status: 'draft'});
            urlService.getUrlByResourceId.withArgs(post.id).returns('/404/');
            urlUtils.urlFor.withArgs({relativeUrl: '/p/' + post.uuid + '/', secure: undefined}, null, true).returns('absolute');
            let url = getUrl(post, true);

            urlService.getUrlByResourceId.calledOnce.should.be.true();
            urlUtils.urlFor.withArgs({relativeUrl: '/p/' + post.uuid + '/', secure: undefined}, null, true)
                .calledOnce.should.be.true();

            url.should.eql('absolute');
        });

        it('absolute, secure', function () {
            const post = testUtils.DataGenerator.forKnex.createPost({status: 'draft'});
            post.secure = true;
            urlService.getUrlByResourceId.withArgs(post.id).returns('/404/');
            urlUtils.urlFor.withArgs({relativeUrl: '/p/' + post.uuid + '/', secure: true}, null, true).returns('absolute secure');
            let url = getUrl(post, true);

            urlService.getUrlByResourceId.calledOnce.should.be.true();
            urlUtils.urlFor.withArgs({relativeUrl: '/p/' + post.uuid + '/', secure: true}, null, true)
                .calledOnce.should.be.true();

            url.should.eql('absolute secure');
        });
    });

    it('should return absolute url for a post', function () {
        const post = testUtils.DataGenerator.forKnex.createPost();

        urlService.getUrlByResourceId.withArgs(post.id, {absolute: true, secure: undefined, withSubdirectory: true})
            .returns('absolute post url');

        getUrl(post, true).should.eql('absolute post url');
    });

    it('should return absolute url for a post and remove /amp/ in url', function () {
        const data = {relativeUrl: '/*/amp/'};

        urlUtils.urlFor.withArgs(data, {}, true).returns('absolute/*/amp/');
        getUrl(data, true).should.eql('absolute/*/');
        urlService.getUrlByResourceId.called.should.be.false();
    });

    it('should return url for a tag', function () {
        const tag = testUtils.DataGenerator.forKnex.createTag();

        // @NOTE: we currently have no way to generate a test model which is correctly jsonified
        //        e.g. testUtils.DataGenerator.forModel.createTag().toJSON()
        //        the tag object contains a `parent` attribute. the tag model contains a `parent_id` attr.
        tag.parent = null;

        urlService.getUrlByResourceId.withArgs(tag.id, {absolute: undefined, secure: undefined, withSubdirectory: true})
            .returns('tag url');

        getUrl(tag).should.eql('tag url');
    });

    it('should return secure url for a tag', function () {
        const tag = testUtils.DataGenerator.forKnex.createTag();

        // @NOTE: we currently have no way to generate a test model which is correctly jsonified
        //        e.g. testUtils.DataGenerator.forModel.createTag().toJSON()
        //        the tag object contains a `parent` attribute. the tag model contains a `parent_id` attr.
        tag.parent = null;

        // @TODO: WTF O_O
        tag.secure = true;

        urlService.getUrlByResourceId.withArgs(tag.id, {absolute: undefined, secure: true, withSubdirectory: true})
            .returns('secure tag url');

        getUrl(tag).should.eql('secure tag url');
    });

    it('should return url for a author', function () {
        const author = testUtils.DataGenerator.forKnex.createUser();

        urlService.getUrlByResourceId.withArgs(author.id, {absolute: undefined, secure: undefined, withSubdirectory: true})
            .returns('author url');

        getUrl(author).should.eql('author url');
    });

    it('should return secure absolute url for a author', function () {
        const author = testUtils.DataGenerator.forKnex.createUser();

        // @TODO: WTF
        author.secure = true;

        urlService.getUrlByResourceId.withArgs(author.id, {absolute: true, secure: true, withSubdirectory: true})
            .returns('absolute secure author url');

        getUrl(author, true).should.eql('absolute secure author url');
    });

    it('should return url for a nav', function () {
        const data = {
            label: 'About Me',
            url: '/about-me/',
            slug: 'about-me',
            current: true
        };

        urlUtils.urlFor.withArgs('nav', {nav: data, secure: data.secure}, undefined)
            .returns('nav url');

        getUrl(data).should.equal('nav url');
    });

    it('should return absolute url for a nav', function () {
        const data = {
            label: 'About Me',
            url: '/about-me/',
            slug: 'about-me',
            current: true
        };

        urlUtils.urlFor.withArgs('nav', {nav: data, secure: data.secure}, true)
            .returns('absolute nav url');

        getUrl(data, true).should.equal('absolute nav url');
    });

    it('should return `relativeUrl` and remove /amp/ in url', function () {
        const data = {relativeUrl: '/*/amp/'};

        urlUtils.urlFor.withArgs(data, {}, undefined).returns(data.relativeUrl);
        getUrl(data).should.eql('/*/');
        urlService.getUrlByResourceId.called.should.be.false();
    });
});