"use strict";

angular.module("vocabulary")
    .config(["$stateProvider",  function ($stateProvider) {

        function getSearchResults($q, $stateParams, wordSearchService) {
            if($stateParams.searchTerm) {
                return wordSearchService.getWordsForSearch($stateParams.searchTerm);
            } else {
                return $q.reject("Search text must not be empty.");
            }
        }

        function getWordTopics(topicService) {
            return topicService.getTopicsWithoutLazConnections();
        }

        function getSubTopics($stateParams, topicService) {
            return topicService.getTopicById($stateParams.topicId).children;
        }

        function getTopicWordData($stateParams, topicService) {
            return topicService.getWordsForTopic($stateParams.topicId, $stateParams.letter);
        }

        function getMemberWords($q, IS_AUTHORIZED_AS_TEACHER, memberWordService) {
            return memberWordService.getMemberWords();
        }

        function getMemberWord($stateParams, memberWordService) {
            return memberWordService.getMemberWord($stateParams.wordId);
        }

        function getCategoryList($stateParams, categoryService){
            return categoryService.getCategoryTree();
        }

        function getCategoryLessons($stateParams, categoryService) {
            return categoryService.getCategoryLessons($stateParams.categoryId);
        }

        function getCategoryId($transition$){
            return $transition$.params().categoryId;
        }

        function getParentCategoryId($transition$){
            return $transition$.params().parentCategoryId;
        }


        function getCategoryName($stateParams, categoryService){
            if($stateParams.categoryName === undefined || $stateParams.categoryName === null){
                var categoryId = parseInt($stateParams.categoryId, 10);
                var category = categoryService.getCategory(categoryId);
                return category ? category.categoryName : '';
            }
            return $stateParams.categoryName;
        }

        function ensureAuthentication(accessRestriction) {
            return accessRestriction.enforceRestriction();
        }

        function getSearchTerm($state) {
            return $state.params.searchTerm;
        }

        function getResourceWordData($stateParams, lessonService) {
            return lessonService.getResourceWordData($stateParams.origin, $stateParams.id);
        }

        function initializeLessonData($stateParams, lessonService) {
            if(!lessonService.userLessonAlreadyInitialized($stateParams.lessonId)) {
                return lessonService.initializeLessonData($stateParams.lessonId);
            }
        }

        function initializeNewLessonData(lessonService) {
            if(!lessonService.unstash(lessonService.getNewLessonStashKey())) {
                return lessonService.initializeLessonData();
            }
        }

        function initializeLessonForPremade($stateParams, lessonService, $state) {
            var re = /(lesson\.premade\.memberWords\.).*/;
            if(!re.test($state.transition.from().name))
                return lessonService.initializeNewLessonFromPremadeOrigin($stateParams.origin, $stateParams.id);
        }

        function getCategoryNameById(categoryService, lessonService) {
            return categoryService.getCategoryName(lessonService.getChosenCategoryId());
        }

        function getTopicId($stateParams) {
            return $stateParams.topicId;
        }

        function getCategoryFilters($transition$, topicService){
            return topicService.getRazTopicFilter(getCategoryId($transition$));
        }

        function getPremadeRazLessonListForBookTopic($transtion$, premadeService){
            return premadeService.getPremadeRazLessonListForBookTopic(getCategoryId($transtion$));
        }

        function getPremadeCategoryLessonList($transition$, premadeService){
            return premadeService.getPremadeCategoryLessonsList(getCategoryId($transition$));
        }

        function getPremadeCategoryDescription($transition$, categoryService){
            return categoryService.getPremadeCategoryDescription(getParentCategoryId($transition$));
        }

        function getPremadeRazLessonListForTopic($transition$, premadeService){
            return premadeService.getPremadeRazLessonListForTopic(getCategoryId($transition$));
        }

        function getPremadeRazLessonListForParentTopic($transition$, premadeService){
            return premadeService.getPremadeRazLessonListForTopic(getParentCategoryId($transition$));
        }

        function getParentCategoryFilters($transition$, topicService){
            return topicService.getRazTopicFilter(getParentCategoryId($transition$));
        }

        function getRazReadingLevels($transition$, premadeNavigationService){
            return premadeNavigationService.getRazReadingLevels();
        }

        function getPremadeRazLeveledLessonList($transition$, premadeService){
            return premadeService.getPremadeRazLeveledLessonList();
        }

        function getRazFictionSeriesCategories($transition$, premadeNavigationService){
            return premadeNavigationService.getRazFictionSeriesCategories();
        }

        function getRazNonFictionSeriesCategories($transition$, premadeNavigationService){
            return premadeNavigationService.getRazNonFictionSeriesCategories();
        }

        function getPremadeRazFictionSeriesList($transition$, premadeService){
            return premadeService.getPremadeRazFictionSeriesList();
        }

        function getPremadeRazNonFictionSeriesList($transition$, premadeService){
            return premadeService.getPremadeRazNonFictionSeriesList();
        }

        function updateCurrentVideoLibraryVideo($stateParams, videos){
            videos.setCurrentVideo($stateParams.id);
        }

        function clearVideoLibraryCache($transition$, videos){
            if($transition$.from() !== $transition$.to()){
                console.log('clear video library caache');
                videos.clearCache();
            }
        }

        function shouldCategorySelectorInitOpen(loginAndContinueService) {
            if (loginAndContinueService.isDataInCache('openCategorySelector')) {
                loginAndContinueService.getDataAndClearCache();
                return true;
            }
            return false;
        }

        function getLessonWordOrderOptionType(lessonWordOrderApi, $stateParams) {
            return lessonWordOrderApi.getLessonWordOrderOptionType($stateParams.lessonId);
        }

        function getMemberProfileInfo(memberService){
            return memberService.getMemberProfileInfo();
        }

        var states = [
            {
                name: "home",
                url: "/",
                component: "home"
            },
            {
                name: "profile",
                url: "/profile",
                component: "profile",
                resolve: {
                    viewInfo: ["memberService", getMemberProfileInfo]
                }
            },
            {
                name: "lesson",
                url: "/lesson",
                abstract: true
            },
            {
                name: "lesson.success",
                url:"/success/{lessonId:[0-9]*}",
                component: "lessonDisplay",
                resolve: {
                    categoryName: ["categoryService", "lessonService", getCategoryNameById],
                    lessonWordOrderType: ["lessonWordOrderApi", "$stateParams", getLessonWordOrderOptionType]
                }
            },


            {
                name: "lesson.new",
                url:"/new",
                resolve: {
                    rootState: [function() {return "lesson.new"}],
                    isCategorySelectorOpen: ["loginAndContinueService", shouldCategorySelectorInitOpen]
                },
                component: "newLessonFrame",
                redirectTo: "lesson.new.wordSearch"
            },
            {
                name: "lesson.new.clear",
                url: "/clear"
            },
            {
                name: "lesson.new.batchEnterWords",
                url:"/batchEnterWords",
                component: "batchEnterWords"
            },
            {
                name: "lesson.new.wordSearch",
                url:"/wordSearch",
                component: "wordSearch"
            },
            {
                name: "lesson.new.wordSearch.results",
                url: "/results/{searchTerm}",
                component: "wordSearchResults",
                resolve: {searchResults: ["$q", "$stateParams", "wordSearchService", getSearchResults]}
            },
            {
                name: "lesson.new.wordSearch.results.new",
                url: "/new",
                views: {"@lesson.new": "addMemberWord"},
                onEnter: ["accessRestriction", ensureAuthentication],
                resolve: {wordName: ["$state", getSearchTerm]}
            },
            {
                name: "lesson.new.wordSearch.results.edit",
                url: "/edit/{wordId:[0-9]{1,10}}",
                views: {"@lesson.new": "editMemberWord"},
                resolve: {word: ["$stateParams", "memberWordService", getMemberWord]}
            },
            {
                name: "lesson.new.wordLists",
                url: "/wordLists/{topicId:[0-9]{1,7}}",
                params: {topicId: {squash: true, value: null}},
                resolve: {
                    topics: ["topicService", getWordTopics],
                    topicId: ["$stateParams", getTopicId]
                },
                abstract: true
            },
            {
                name: "lesson.new.wordLists.root",
                url: "/root",
                component: "wordLists"
            },
            {
                name: "lesson.new.wordLists.subTopics",
                url: "/subTopics",
                component:  "subTopic",
                resolve: {topicList: ["$stateParams", "topicService", getSubTopics]}
            },
            {
                name: "lesson.new.wordLists.topicWords",
                url: "/words/{letter:(?:[A-Z]*)}",
                params: {letter: {squash: true, value: null}},
                component: "subTopicWords",
                resolve: {data: ["$stateParams", "topicService", getTopicWordData]}
            },

            {
                name: "lesson.new.memberWords",
                url: "/yourWords",
                component: "memberWords",
                resolve: {memberWords: ["$q", "IS_AUTHORIZED_AS_TEACHER", "memberWordService", getMemberWords]}
            },
            {
                name: "lesson.new.memberWords.new",
                url: "/new",
                views: {"@lesson.new": "addMemberWord"}
            },
            {
                name: "lesson.new.memberWords.edit",
                url: "/edit/{wordId:[0-9]{1,10}}",
                views: {"@lesson.new": "editMemberWord"},
                resolve: {word: ["$stateParams", "memberWordService", getMemberWord]}
            },

            {
                name: "lesson.edit",
                url:"/edit/{lessonId:[0-9]*}",
                resolve: {rootState: [function() {return "lesson.edit"}]},
                onEnter: ["$stateParams", "lessonService", initializeLessonData],
                component: "editLessonFrame",
                redirectTo: "lesson.edit.wordSearch"
            },
            {
                name: "lesson.edit.wordSearch",
                url:"/wordSearch",
                component: "wordSearch"
            },
            {
                name: "lesson.edit.wordSearch.results",
                url: "/results/{searchTerm}",
                component: "wordSearchResults",
                resolve: {searchResults: ["$q", "$stateParams", "wordSearchService", getSearchResults]}
            },
            {
                name: "lesson.edit.wordSearch.results.new",
                url: "/new",
                views: {"@lesson.edit": "addMemberWord"},
                onEnter: ["accessRestriction", ensureAuthentication],
                resolve: {wordName: ["$state", getSearchTerm]}
            },
            {
                name: "lesson.edit.wordSearch.results.edit",
                url: "/edit/{wordId:[0-9]{1,10}}",
                views: {"@lesson.edit": "editMemberWord"},
                resolve: {word: ["$stateParams", "memberWordService", getMemberWord]}
            },
            {
                name: "lesson.edit.wordLists",
                url: "/wordLists/{topicId:[0-9]{1,7}}",
                params: {topicId: {squash: true, value: null}},
                resolve: {
                    topics: ["topicService", getWordTopics],
                    topicId: ["$stateParams", getTopicId]
                },
                abstract: true
            },
            {
                name: "lesson.edit.wordLists.root",
                url: "/root",
                component: "wordLists"
            },
            {
                name: "lesson.edit.wordLists.subTopics",
                url: "/subTopics",
                component:  "subTopic",
                resolve: {topicList: ["$stateParams", "topicService", getSubTopics]}
            },
            {
                name: "lesson.edit.wordLists.topicWords",
                url: "/words/{letter:(?:[A-Z]*)}",
                params: {letter: {squash: true, value: null}},
                component: "subTopicWords",
                resolve: {data: ["$stateParams", "topicService", getTopicWordData]}
            },

            {
                name: "lesson.edit.memberWords",
                url: "/yourWords",
                component: "memberWords",
                resolve: {memberWords: ["$q", "IS_AUTHORIZED_AS_TEACHER", "memberWordService", getMemberWords]}
            },
            {
                name: "lesson.edit.memberWords.new",
                url: "/new",
                views: {"@lesson.edit": "addMemberWord"}
            },
            {
                name: "lesson.edit.memberWords.edit",
                url: "/edit/{wordId:[0-9]{1,10}}",
                views: {"@lesson.edit": "editMemberWord"},
                resolve: {word: ["$stateParams", "memberWordService", getMemberWord]}
            },
            {
                name: "lesson.razbookpremade",
                url:"/razbookpremade/{bookId:(?:new|[0-9]*)}"
            },
            {
                name: "lesson.premade",
                url: "/premade/{origin:[a-zA-Z_]*}/{id:[0-9]*}",
                resolve: {rootState: [function() {return "lesson.premade"}]},
                onEnter: ["$stateParams", "lessonService", "$state", initializeLessonForPremade],
                component: "premadeLessonFrame"
            },
            {
                name: "lesson.premade.resourceWords",
                url: "/resourceWords",
                component: "resourceWords",
                resolve: {data: ["$stateParams", "lessonService", getResourceWordData]}
            },
            {
                name: "lesson.premade.wordSearch",
                url:"/wordSearch",
                component: "wordSearch"
            },
            {
                name: "lesson.premade.wordSearch.results",
                url: "/results/{searchTerm}",
                component: "wordSearchResults",
                resolve: {searchResults: ["$q", "$stateParams", "wordSearchService", getSearchResults]}
            },
            {
                name: "lesson.premade.wordSearch.results.new",
                url: "/new",
                views: {"@lesson.premade": "addMemberWord"},
                onEnter: ["accessRestriction", ensureAuthentication],
                resolve: {wordName: ["$state", getSearchTerm]}
            },
            {
                name: "lesson.premade.wordSearch.results.edit",
                url: "/edit/{wordId:[0-9]{1,10}}",
                views: {"@lesson.premade": "editMemberWord"},
                resolve: {word: ["$stateParams", "memberWordService", getMemberWord]}
            },
            {
                name: "lesson.premade.wordLists",
                url: "/wordLists/{topicId:[0-9]{1,7}}",
                params: {topicId: {squash: true, value: null}},
                resolve: {
                    topics: ["topicService", getWordTopics],
                    topicId: ["$stateParams", getTopicId]
                },
                abstract: true
            },
            {
                name: "lesson.premade.wordLists.root",
                url: "/root",
                component: "wordLists"
            },
            {
                name: "lesson.premade.wordLists.subTopics",
                url: "/subTopics",
                component:  "subTopic",
                resolve: {topicList: ["$stateParams", "topicService", getSubTopics]}
            },
            {
                name: "lesson.premade.wordLists.topicWords",
                url: "/words/{letter:(?:[A-Z]*)}",
                params: {letter: {squash: true, value: null}},
                component: "subTopicWords",
                resolve: {data: ["$stateParams", "topicService", getTopicWordData]}
            },

            {
                name: "lesson.premade.memberWords",
                url: "/yourWords",
                component: "memberWords",
                resolve: {memberWords: ["$q", "IS_AUTHORIZED_AS_TEACHER", "memberWordService", getMemberWords]}
            },
            {
                name: "lesson.premade.memberWords.new",
                url: "/new",
                views: {"@lesson.premade": "addMemberWord"}
            },
            {
                name: "lesson.premade.memberWords.edit",
                url: "/edit/{wordId:[0-9]{1,10}}",
                views: {"@lesson.premade": "editMemberWord"},
                resolve: {word: ["$stateParams", "memberWordService", getMemberWord]}
            },

            {
                name: "yourLessons",
                url: "/yourLessons/category",
                component: "yourLessons",
                params: {
                    categoryList: []
                },
                resolve: {
                    categoryList: ["$stateParams", "categoryService", getCategoryList]
                },
                redirectTo: {
                    state: "yourLessons.category",
                    params: {
                        categoryId: 0,
                        categoryName: 'Uncategorized',
                        lessons: []
                    }
                }
            },

            {
                name: "yourLessons.category",
                url:"/{categoryId}",
                component: "yourLesson",
                params: {
                    categoryName: null,
                    lessons: [],
                    parentCategoryId: ''
                },
                resolve: {
                    categoryName: ["$stateParams", "categoryService", getCategoryName],
                    categoryId: ["$transition$", getCategoryId],
                    parentCategoryId: ["$transition$", getParentCategoryId],
                    lessons: ["$stateParams", "categoryService", getCategoryLessons]
                }
            },
            {
                name: "premadeLessons",
                url: "/premadeLessons",
                views:{
                    '': "premadeLessons",
                   'premadeNav@premadeLessons': "premadeNavigation"
               },
                redirectTo: {
                   state: "premadeLessons.razLeveledBooks",
                   params: {
                       categoryId: 0,
                       parentCategoryId: 3
                   }
               }
            },

            {
                name: "premadeLessons.readingSeries",
                url: "/reading-series/{parentCategoryId}/{categoryId}",
                views: {
                    '@premadeLessons': "premadeLessonsRevamp",
                    'premadeNav@premadeLessons' : 'readingSeriesNav', // todo - we should really only have a single nav, removing the need for multiple ui-views
                    'premadeContent@premadeLessons': "premadeCollection"
                },
                resolve: {
                    categoryId: ["$transition$", getCategoryId],
                    parentCategoryId: ["$transition$", getParentCategoryId],
                    levels: ["$transition$", "topicService", getCategoryFilters],
                    resources: ["$transition$", "premadeService", getPremadeCategoryLessonList],
                    description: ["$transition$", "categoryService", getPremadeCategoryDescription]
                }
            },

            {
                name: "premadeLessons.collection",
                url: "/collection/{parentCategoryId}/{categoryId}",
                views:{
                    'premadeContent@premadeLessons': "premadeCollection"
                },
                params:{
                    levels: [],
                    resources: []
                },
                resolve: {
                    categoryId: ["$transition$", getCategoryId],
                    parentCategoryId: ["$transition$", getParentCategoryId],
                    levels: ["$transition$", "topicService", getCategoryFilters],
                    resources: ["$transition$", "premadeService", getPremadeCategoryLessonList]
                }
            },
            {
                name: "premadeLessons.science",
                url: "/science/{parentCategoryId}/{categoryId}",
                views:{
                    'premadeContent@premadeLessons': "premadeScience"
                },
                params:{
                    levels: [],
                    resources: []
                },
                resolve: {
                    categoryId: ["$transition$", getCategoryId],
                    parentCategoryId: ["$transition$", getParentCategoryId],
                    levels: ["$transition$", "topicService", getCategoryFilters],
                    resources: ["$transition$", "premadeService", getPremadeCategoryLessonList]
                }
            },

            {
                name: "premadeLessons.ellLanguageSkill",
                url: "/ell/skillPack/{parentCategoryId}/{categoryId}",
                views:{
                    'premadeContent@premadeLessons': "premadeEllLanguageSkill"
                },
                params:{
                    levels: [],
                    resources: null
                },
                resolve: {
                    categoryId: ["$transition$", getCategoryId],
                    parentCategoryId: ["$transition$", getParentCategoryId],
                    levels: ["$transition$", "topicService", getParentCategoryFilters],
                    resources: ["$transition$", "premadeService", getPremadeRazLessonListForParentTopic]
                }
            },

            {
                name: "premadeLessons.ellPowerPack",
                url: "/ell/powerPack/{parentCategoryId}/{categoryId}",
                views:{
                    'premadeContent@premadeLessons': "premadeEllPowerPack"
                },
                params:{
                    levels: [],
                    resources: null
                },
                resolve: {
                    categoryId: ["$transition$", getCategoryId],
                    parentCategoryId: ["$transition$", getParentCategoryId],
                    levels: ["$transition$", "topicService", getCategoryFilters],
                    resources: ["$transition$", "premadeService", getPremadeRazLessonListForTopic]
                }
            },

            {
                name: "premadeLessons.ellVocabBooks",
                url: "/ell/vocabBooks/{parentCategoryId}/{categoryId}",
                views:{
                    'premadeContent@premadeLessons': "premadeEllVocabBooks"
                },
                params:{
                    levels: [],
                    resources: null
                },
                resolve: {
                    categoryId: ["$transition$", getCategoryId],
                    parentCategoryId: ["$transition$", getParentCategoryId],
                    levels: ["$transition$", "topicService", getCategoryFilters],
                    resources: ["$transition$", "premadeService", getPremadeRazLessonListForBookTopic]
                }
            },

            {
                name: "premadeLessons.razLeveledBooks",
                url: "/reading/leveled/{parentCategoryId}/{categoryId}",
                views:{
                    'premadeContent@premadeLessons': "premadeReading"
                },
                params:{
                    levels: [],
                    resources: null
                },
                resolve: {
                    parentCategoryId: ["$transition$", getParentCategoryId],
                    categoryId: ["$transition$", getCategoryId],
                    levels: ["$transition$", "premadeNavigationService", getRazReadingLevels],
                    resources: ['$transition$', "premadeService", getPremadeRazLeveledLessonList]
                }
            },
            {
                name: "premadeLessons.razMathBooks",
                url: "/reading/math/{parentCategoryId}/{categoryId}",
                views:{
                    'premadeContent@premadeLessons': "premadeRazMath"
                },
                params: {
                    levels: [],
                    resources: null
                },
                resolve: {
                    categoryId: ["$transition$", getCategoryId],
                    parentCategoryId: ["$transition$", getParentCategoryId],
                    levels: ["$transition$", "topicService", getCategoryFilters],
                    resources: ["$transition$", "premadeService", getPremadeRazLessonListForBookTopic]
                }
            },
            {
                name: "premadeLessons.razVocabBooks",
                url: "/reading/vocab/{parentCategoryId}/{categoryId}",
                views:{
                    'premadeContent@premadeLessons': "premadeRazVocab"
                },
                params: {
                    levels: [],
                    resources: null
                },
                resolve: {
                    categoryId: ["$transition$", getCategoryId],
                    parentCategoryId: ["$transition$", getParentCategoryId],
                    levels: ["$transition$", "topicService", getCategoryFilters],
                    resources: ["$transition$", "premadeService", getPremadeRazLessonListForBookTopic]
                }
            },

            {
                name: "premadeLessons.razSharedReading",
                url: "/reading/shared/{parentCategoryId}/{categoryId}",
                views:{
                    'premadeContent@premadeLessons': "premadeRazShared"
                },
                params:{
                    levels: [],
                    resources: null
                },
                resolve:{
                    categoryId: ["$transition$", getCategoryId],
                    parentCategoryId: ["$transition$", getParentCategoryId],
                    levels: ["$transition$", "topicService", getCategoryFilters],
                    resources: ["$transition$", "premadeService", getPremadeRazLessonListForBookTopic]
                }
            },

            {
                name: "premadeLessons.razGraphic",
                url: "/reading/graphic/{parentCategoryId}/{categoryId}",
                views:{
                    'premadeContent@premadeLessons': "premadeRazGraphic"
                },
                params:{
                    levels: [],
                    resources: null
                },
                resolve:{
                    categoryId: ["$transition$", getCategoryId],
                    parentCategoryId: ["$transition$", getParentCategoryId],
                    resources: ["$transition$", "premadeService", getPremadeRazLessonListForBookTopic]
                }
            },

            {
                name: "premadeLessons.razFictionSeries",
                url: "/reading/fiction/{parentCategoryId}/{categoryId}",
                views:{
                    'premadeContent@premadeLessons': "premadeSeries"
                },
                params:{
                    levels: [],
                    resources: null
                },
                resolve: {
                    parentCategoryId: ["$transition$", getParentCategoryId],
                    categoryId: ["$transition$", getCategoryId],
                    levels: ["$transition$", "premadeNavigationService", getRazFictionSeriesCategories],
                    resources: ['$transition$', "premadeService", getPremadeRazFictionSeriesList]
                }
            },

            {
                name: "premadeLessons.razNonFictionSeries",
                url: "/reading/nonfiction/{parentCategoryId}/{categoryId}",
                views:{
                    'premadeContent@premadeLessons': "premadeSeries"
                },
                params:{
                    levels: [],
                    resources: null
                },
                resolve: {
                    parentCategoryId: ["$transition$", getParentCategoryId],
                    categoryId: ["$transition$", getCategoryId],
                    levels: ["$transition$", "premadeNavigationService", getRazNonFictionSeriesCategories],
                    resources: ['$transition$', "premadeService", getPremadeRazNonFictionSeriesList]
                }
            },


            {
                name: "premadeLessons.razLeveledBook",
                url: "/reading/leveled/level/{levelId:[0-9]*}/book/{bookId:[0-9]*}"
            },
            {
                name: "premadeLessons.razLevel",
                url: "/reading/leveled/level/{levelId:[0-9]*}"
            },

            {name: "manageStudents", url: "/manageStudents", component: "manageStudents"},
            {name: "sample", url: "/sample", component: "freeSample"},
            {name: "sample.confirmation", url: "/confirmation", component: "sampleAgeConfirmation"},
            {name: "sample.access", url: "/access", component: "sampleAccess"},
            {
                name: "videoLibrary",
                url: '/videoLibrary?id={int}',
                component: "vocabVideoLibrary",
                resolve: { currentVideoId: [ '$stateParams', 'videos', updateCurrentVideoLibraryVideo ]},
                onExit: [ '$transition$', 'videos', clearVideoLibraryCache ]
            },
            {
                name: "standardsAndCorrelations",
                url: "/standardsAndCorrelations",
                views:{
                    '': "standardsAndCorrelations",
                    'standardsNav@standardsAndCorrelations': "standardsAndCorrelationsNavigation"
                },
                redirectTo: {
                    state: "standardsAndCorrelations.usStateStandards"
                }
            },
            {
                name: "standardsAndCorrelations.usStateStandards",
                url: "/usStateStandards",
                views: {
                    'standardsContent@standardsAndCorrelations': "usStateStandards"
                }
            },

            {
                name: "standardsAndCorrelations.commonCoreStandards",
                url: "/commonCoreStandards",
                views: {
                    'standardsContent@standardsAndCorrelations': "commonCoreStandards"
                }
            },
            {
                name: "standardsAndCorrelations.internationalStandards",
                url: "/internationalStandards",
                views: {
                    'standardsContent@standardsAndCorrelations': "internationalStandards"
                }
            },
            {
                name: "standardsAndCorrelations.languageProficiencyStandards",
                url: "/languageProficiencyStandards",
                views: {
                    'standardsContent@standardsAndCorrelations': "languageProficiencyStandards"
                }
            }

        ];

        states.forEach(function (state) {
            $stateProvider.state(state);
        });
    }])
    .run(["$urlService", "$transitions", "$state", "lessonService", "loginAndContinueService",
            "premadeService", "wordSearchService", "premadeNavigationService", "accessRestriction", "utilService", "FeatureCheck",
        function($urlService, $transitions, $state, lessonService,loginAndContinueService,
                 premadeService, wordSearchService, premadeNavigationService, accessRestriction, utilService, FeatureCheck) {

        utilService.setTitleFromFirstH1IfAny();
        utilService.setMetaDescriptionFromPath();
        premadeNavigationService.initService();

        $urlService.rules.otherwise("/");

        $transitions.onFinish({exiting: 'lesson'}, function (transition) {
            wordSearchService.clearSearchText();
        });

        $transitions.onStart({to: "lesson.success"}, function (transition) {
            var lessonId = transition.params("to").lessonId;
            return lessonService.initializeLessonData(lessonId);
        });

        $transitions.onStart({to: "lesson.new.clear"}, function (transition) {
            wordSearchService.clearSearchText();
            lessonService.initializeLessonData();
            lessonService.clearStash(lessonService.getNewLessonStashKey());
            return transition.router.stateService.target("lesson.new", {}, {reload:true});
        });

        $transitions.onStart({from: "lesson.new.**"}, function (transition) {
            lessonService.stash(lessonService.getNewLessonStashKey());
        });

        $transitions.onBefore({to: "lesson.*.memberWords"}, function(transition) {
            var redirectUrl = null;
            var url = $state.href(transition.to()['name'], {}, {relative: '/'});
            if (url) {
                redirectUrl = url.replace('#!', '');
            }
            return accessRestriction.enforceRestriction(null, redirectUrl);
        });

        $transitions.onStart({to: "lesson.new.**"}, function (transition) {
            if (loginAndContinueService.isDataInCache('word')) {
                var word = loginAndContinueService.getDataAndClearCache()['word'];
                lessonService.toggleChosenWord(word);
            }
        });

        $transitions.onFinish({to: "lesson.premade"}, function (transition) {
            if(lessonService.doesLessonHaveResourceWords()) {
                return transition.router.stateService.target("lesson.premade.resourceWords", transition.params("to"));
            } else {
                return transition.router.stateService.target("lesson.premade.wordSearch", transition.params("to"));
            }
        });

        $transitions.onStart({to: "lesson.razbookpremade"}, function (transition) {
            var bookId = transition.params("to").bookId;
            return premadeService.getPremadeLessonForRazBook(bookId)
                .then(function (premadeLesson) {
                    return transition.router.stateService.target("lesson.premade", {origin: 'raz_premade', id : premadeLesson.lessonId});
                });
        });

        $transitions.onStart({to: "premadeLessons.razLeveledBook"}, function (transition) {
            var bookId = transition.params("to").bookId;
            var levelId = transition.params("to").levelId;
            return accessRestriction.enforceRestriction()
                .then(function () {
                    return premadeService.getPremadeLessonForRazBook(bookId)
                        .then(function (premadeLesson) {
                            var targetState = transition.router.stateService.target("premadeLessons.razLeveledBooks", {parentCategoryId: 3, categoryId: 0});
                            premadeNavigationService.setSelectedPremadeLessonId(premadeLesson.lessonId);
                            premadeNavigationService.setCurrentRazReadingLevelByID(levelId);
                            return targetState;
                        });
                })
                .catch(function () {
                    return transition.router.stateService.target("premadeLessons");
                });
        });

        $transitions.onStart({to: "premadeLessons.razLevel"}, function (transition) {
            var levelId = transition.params("to").levelId;
            premadeNavigationService.setCurrentRazReadingLevelByID(levelId);
            return transition.router.stateService.target("premadeLessons.razLeveledBooks", {parentCategoryId: 3, categoryId: 0});
        });

        $transitions.onBefore({entering: "yourLessons"}, function(transition){
            return accessRestriction.enforceRestriction()
                .catch(function () {
                    return transition.$from().navigable ? false : transition.router.stateService.target("home"); // todo - this may be better placed in "ensureAuthentication". if so, this transition rule can be removed.
                });
        });

        $transitions.onStart({to: "premadeLessons.collection"}, function(transition){
            if(FeatureCheck.isFeatureEnabled('VAZ_PREMADE_NAV_REDESIGN')) {
                var parentCategoryId = transition.params("to").parentCategoryId;
                var categoryId = transition.params("to").categoryId;
                return transition.router.stateService.target("premadeLessons.readingSeries", {parentCategoryId: parentCategoryId, categoryId: categoryId});
            }
        });

      $transitions.onStart({entering: "premadeLessons"}, function(transition){
            return premadeNavigationService.getPremadeCategoryTree().then(function(result){
                var parentCategoryId = transition.params("to").parentCategoryId;
                var categoryId = transition.params("to").categoryId;
                premadeNavigationService.setSelectedPremadeCategory(parentCategoryId, categoryId);
                var lessonData = loginAndContinueService.getDataAndClearCache();
                if(lessonData){
                    premadeNavigationService.setSelectedPremadeLessonId(lessonData['lid']);
                }
            });
        });


    $transitions.onStart({entering: "profile"}, function(transition) {
        console.log("entering profile");
    });
      $transitions.onSuccess({}, function(transition) {
          utilService.setMetaDescriptionFromState();
      });
    }]);