'use strict';

(function (module) {
    module.service('InventoryFilterService', ['$http', '$q', '$location', '$timeout', 'Config', function ($http, $q, $location, $timeout, Config) {

        var ctrl = this;
        var mainUrl = window.location.protocol + '//' + window.location.host + '/';

        //range acceptable for filter bars
        var filterLimits = {
            MinMileage: 25000,
            MaxMileage: 250000,
            MileageIncrement: 25000,
            MinDistanceRange: 5,
            MaxDistanceRange: 255,
            DistanceIncrement: 5,
            MaxDistanceAcceptable: 250,
            MaxYearRange: new Date().getFullYear() + 1,
            MinYearRange: 1980,
            YearIncrement: 1,
            MinPrice: 0,
            MaxPrice: 100000,
            PriceIncrement: 1000
        };

        var selectedFilters = {
            filters: {
                Condition: [],
                Makes: [],
                DealerContactlessServices: [],
                MakeModel: [],
                VehicleType: [],
                PriceRange: [],
                YearRange: [],
                MaxMiles: 250000,
                Trims: [],
                Colors: [],
                PriceAnalysis: ['Great', 'Fair', 'None'],
                Distance: Config.DefaultSearchDistance,
                ZipCode: "",
                MinPrice: 0,
                MaxPrice: 100000,
                MinYear: 1980,
                MaxYear: new Date().getFullYear() + 1,
                ASXOnly: false,
                SortBy: 'DistanceNearToFar',
                Type: '',
                IsSpecialty: false,
                DealerClientCode: '',
                ItemType: 5,
                Carfax1Owner: false,
                NewlyListed: false,
                PriceDrop: false,
                Gas: false,
                FuelOptions: [],
                TransmissionType: [],
                Cylinder: [],
                DrivetrainType: [],
                MPGMin: null,
                MPGMax: null
            },
            currentPage: 0
        };

        function newfilterOptions() {
            return {
                VisibleVehicles: 15,
                VisibleMoreVehicles: 15,
                VisibleSpotlightVehciles: 3,
                Conditions: [
                    { 'Key': 'New', 'SearchValue': 'New' }, { 'Key': 'Used', 'SearchValue': 'Used' }
                ],
                Makes: [],
                MakeModel: [],
                MakeSelected: false,
                ModelSelected: false,
                DealerContactlessServices: [
                    { 'Key': 'Contactless Purchase', 'SearchValue': 'ContactlessPurchase' },
                    { 'Key': 'Virtual Appointments', 'SearchValue': 'VirtualAppointments' },
                    { 'Key': 'Free Test Drive at Home', 'SearchValue': 'FreeTestDriveAtHome' },
                    { 'Key': 'Free Home Delivery', 'SearchValue': 'FreeHomeDelivery' },
                ],
                VehicleType: [
                    { 'Key': 'SUVs', 'SearchValue': 'Suv' },
                    { 'Key': 'Sedans', 'SearchValue': 'Sedan' },
                    { 'Key': 'Luxury Cars', 'SearchValue': 'Luxury' },
                    { 'Key': 'Sports Cars', 'SearchValue': 'Sportscar' },
                    { 'Key': 'Pickup Trucks', 'SearchValue': 'Truck' },
                    { 'Key': 'Wagons', 'SearchValue': 'Wagon' },
                    { 'Key': 'Minivans/Vans', 'SearchValue': 'Van' },
                    { 'Key': 'Convertibles', 'SearchValue': 'Convertible' },
                    { 'Key': 'Coupes', 'SearchValue': 'Coupe' },
                    { 'Key': 'Electric/Hybrid', 'SearchValue': 'Electric' },
                    { 'Key': 'Hatchback', 'SearchValue': 'Hatchback' }],
                TransmissionType: [
                    { 'Key': 'Manual', 'SearchValue': 'Manual' },
                    { 'Key': 'Automatic', 'SearchValue': 'Automatic' },
                ],
                Cylinder: [
                    { 'Key': '4', 'SearchValue': '4' },
                    { 'Key': '6', 'SearchValue': '6' },
                    { 'Key': '8', 'SearchValue': '8' },
                    { 'Key': 'Other', 'SearchValue': 'Other' }
                ],
                DrivetrainType: [
                    { 'Key': 'Rear Wheel', 'SearchValue': 'RearWheel' },
                    { 'Key': 'Front Wheel', 'SearchValue': 'FrontWheel' },
                    { 'Key': 'All Wheel', 'SearchValue': 'AllWheel' }
                ],
                PriceRange: [],
                YearRange: [],
                MaxMiles: 0,
                Trims: [],
                Colors: [],
                PriceAnalysis: [],
                Distance: 0,
                ZipCode: "",
                SortBy: [
                    { 'Key': 'Sort By Distance (Near to Far)', 'SearchValue': 'DistanceNearToFar' },
                    { 'Key': 'Sort By Price (Low to High)', 'SearchValue': 'PriceLowToHigh' },
                    { 'Key': 'Sort By Price (High to Low)', 'SearchValue': 'PriceHighToLow' },
                    { 'Key': 'Sort By Year (Newest to Oldest)', 'SearchValue': 'YearNewToOld' },
                    { 'Key': 'Sort By Year (Oldest to Newest)', 'SearchValue': 'YearOldToNew' },
                    { 'Key': 'Sort By Mileage (Low to High)', 'SearchValue': 'OdometerLowToHigh' },
                    { 'Key': 'Sort By Preferred Dealers', 'SearchValue': 'PreferredDealer' }
                ],
                FuelOptions: [],
                MPGMin: null,
                MPGMax: null
            };
        }

        var clearMakeSelectedFilters = function () {
            if (selectedFilters.filters.Makes.length > 0) {
                selectedFilters.filters.Makes.length = 0;
            }
        };

        var setupSelectedFilters = function () {          
            var search = $location.search();
            var newObject = {};
            angular.forEach(search, function (value, key) {
                newObject[key.toLowerCase()] = value;
            });

            if (Config.EnablePriceGuidance === 'true') {
                selectedFilters.filters.PriceAnalysis.push('AboveAverage');
            }

            angular.forEach(selectedFilters.filters, function (value, key) {
                var keyLower = key.toLowerCase();
                if (keyLower == 'makes') {
                    clearMakeSelectedFilters();
                }
                if (keyLower in newObject) {
                    if (keyLower == 'makes') {
                        filterOptions.MakeSelected = true;
                    }
                    if (keyLower == 'makemodel') {
                        filterOptions.ModelSelected = true;
                        if (typeof newObject[keyLower] === 'object') {
                            angular.forEach(newObject[keyLower], function (value) {
                                if (value.indexOf('|') > 0) {
                                    var makeModelArry = value.split('|');
                                    var makeModelObj = { Make: makeModelArry[0], Model: makeModelArry[1] }
                                    selectedFilters.filters['MakeModel'].push(makeModelObj);
                                }
                            });
                        }
                        else {
                            if (newObject[keyLower].indexOf('|') > 0) {
                                var makeModelArry = newObject[keyLower].split('|');
                                var makeModelObj = { Make: makeModelArry[0], Model: makeModelArry[1] }
                                selectedFilters.filters['MakeModel'].push(makeModelObj);
                            }
                        }
                    } else if (keyLower == 'trims') {
                        if (typeof newObject[keyLower] === 'object') {
                            angular.forEach(newObject[keyLower], function (value) {
                                if (value.indexOf('|') > 0) {
                                    var trimArry = value.split('|');
                                    var trimObj = { Make: trimArry[0], Model: trimArry[1], Trim: trimArry[2] }
                                    selectedFilters.filters['Trims'].push(trimObj);
                                }
                            });
                        }
                        else {
                            if (newObject[keyLower].indexOf('|') > 0) {
                                var trimArry = newObject[keyLower].split('|');
                                var trimObj = { Make: trimArry[0], Model: trimArry[1], Trim: trimArry[2] }
                                selectedFilters.filters['Trims'].push(trimObj);
                            }
                        }
                    }
                    else if (keyLower == 'mpgmin') {
                        selectedFilters.filters['MPGMin'] = newObject[key.toLowerCase()];
                    }
                    else if (keyLower == 'mpgmax') {
                        selectedFilters.filters['MPGMax'] = newObject[key.toLowerCase()];
                    }
                    else if (typeof selectedFilters.filters[key] === 'string') {
                        selectedFilters.filters[key] = newObject[keyLower];
                    } else if (typeof selectedFilters.filters[key] === 'boolean') {
                        selectedFilters.filters[key] = newObject[keyLower];
                    } else if (typeof selectedFilters.filters[key] === 'object') {
                        selectedFilters.filters[key] = [];
                        if (typeof newObject[keyLower] === 'object') {
                            angular.forEach(newObject[keyLower], function (value) {
                                if (selectedFilters.filters[key].indexOf(value.toLowerCase()) < 0) {
                                    selectedFilters.filters[key].push(value);
                                }
                            });
                        }
                        else {
                            selectedFilters.filters[key].push(newObject[keyLower]);
                        }
                    } else if (typeof selectedFilters.filters[key] === 'number') {
                        selectedFilters.filters[key] = newObject[keyLower];
                    }
                }
            });

            selectedFilters.filters.ZipCode = Config.ZipCode;
            selectedFilters.filters.IsSpecialty = (selectedFilters.filters.Type.toLowerCase() == 'specialty' || (selectedFilters.filters.ItemType != 5 && selectedFilters.filters.ItemType != 'Car'));
        };

        var getVehicleTypes = function () {
            filterOptions.VehicleType = [];
            if (selectedFilters.filters.IsSpecialty) {

                getSpecialtyVehicles(Config.ClientWebSiteID).then(function (data) {
                    if (data.data) {
                        data = data.data;
                    }
                    angular.forEach(data,
                        function (vehicleType) {
                            var vehicle = { 'Key': vehicleType.Key, 'SearchValue': vehicleType.SearchValue };
                            filterOptions.VehicleType.push(vehicle);

                        });
                });
            }
            else {
                filterOptions.VehicleType = [{ 'Key': 'SUVs', 'SearchValue': 'Suv' },
                { 'Key': 'Sedans', 'SearchValue': 'Sedan' },
                { 'Key': 'Luxury Cars', 'SearchValue': 'Luxury' },
                { 'Key': 'Sports Cars', 'SearchValue': 'Sportscar' },
                { 'Key': 'Pickup Trucks', 'SearchValue': 'Truck' },
                { 'Key': 'Wagons', 'SearchValue': 'Wagon' },
                { 'Key': 'Minivans/Vans', 'SearchValue': 'Van' },
                { 'Key': 'Convertibles', 'SearchValue': 'Convertible' },
                { 'Key': 'Coupes', 'SearchValue': 'Coupe' },
                { 'Key': 'Electric/Hybrid', 'SearchValue': 'Electric' },
                { 'Key': 'Hatchback', 'SearchValue': 'Hatchback' }];
            }
        };

        function setFuelOptions() {
            filterOptions.FuelOptions = [
                { 'Key': 'Gas', 'SearchValue': 'gas' },
                { 'Key': 'Electric', 'SearchValue': 'electric' },
                { 'Key': 'Hybrid', 'SearchValue': 'hybrid' },
                { 'Key': 'Other', 'SearchValue': 'other' }
            ];
        }

        var filterOptions = newfilterOptions();

        var IsDataLoaded = false;
        var init = function () {

            setupSelectedFilters();
            getVehicleTypes();
            getPriceAnalysis();
            setFuelOptions();

            if (IsDataLoaded) {
                return $q.resolve();
            }
            IsDataLoaded = true;
            return $q.all([

                    retrieveMakes(selectedFilters.filters.IsSpecialty)
                        .then(function (data) {
                            if (data.data) {
                                data = data.data;
                            }
                            angular.forEach(data,
                                function (make) {
                                    filterOptions.Makes.push(make.Make);

                                });


                        }),
                    getAllModels(),
                    getAllTrims(),
                    GetVehicleColors()
                    .then(function (data) {
                        if (data.data) {
                            data = data.data;
                        }
                        angular.forEach(data,
                            function (color) {
                                var colorRecord = { 'Key': color.Name, 'StyleValue': { "color": color.Hexidecimal } };
                                filterOptions.Colors.push(colorRecord);
                            });
                    })
            ]).then(function () {


            });



        };

        var getAllModels = function () {
            var deferred = $q.defer();

            angular.forEach(selectedFilters.filters.Makes, function (make) {
                getModels(make).then(function (data) {
                    if (data.data) {
                        data = data.data;
                    }
                    angular.forEach(data, function (model) {
                        var makeModel = {
                            Make: make,
                            Model: model.Model
                        };
                        filterOptions.MakeModel.push(makeModel);
                    });
                });
            });
            return $q.promise;
        }

        var getAllTrims = function () {
            var deferred = $q.defer();

            angular.forEach(selectedFilters.filters.MakeModel, function (model) {
                getTrims(model.Make, model.Model, selectedFilters.filters.Condition === 'New').then(function (data) {
                    if (data.data) {
                        data = data.data;
                    }
                    angular.forEach(data, function (trim) {
                        var makeModelTrim = {
                            Make: model.Make,
                            Model: model.Model,
                            Trim: trim
                        };
                        filterOptions.Trims.push(makeModelTrim);
                    });
                });
            });
            return $q.promise;
        }

        var retrieveMakes = function (isSpecialty) {

            if (isSpecialty) {
                return getSpecialtyMakes();
            }

            return getInventoryMakes();
        };

        var getSpecialtyMakes = function (specialtyList) {
            var deferred = $q.defer();
            var url = mainUrl + 'Search/GetSpecialtyMakes/';
            if (specialtyList && specialtyList.length > 0) {
                url += '?specialList=' + specialtyList;
            }
            var promise = $http({
                method: 'GET',
                url: url,

                headers: {
                    'Content-Type': 'application/json',
                    'Accept': '*/*',
                    'Accept-Language': 'en-US,en;q=0.8'

                }

            }).then(function (data) {
                if (data.data) {
                    data = data.data;
                }
                deferred.resolve(data);
            }).catch(function (data) {
                deferred.reject(data);
            });
            return deferred.promise;

        };

        function getSpecialtyVehicles(clientWebsiteID) {

            var deferred = $q.defer();
            var spe = JSON.parse(Config.SpecialtyVehicleTypes.replace(/&quot;/g, '"'));

            deferred.resolve(spe);
            return deferred.promise;
        }

        function getPriceAnalysis() {
            filterOptions.PriceAnalysis = [{ 'Key': 'Great Price', 'SearchValue': 'Great' },
                { 'Key': 'Fair Price', 'SearchValue': 'Fair' }];

            if (Config.EnablePriceGuidance === 'true') {
                filterOptions.PriceAnalysis.push({ 'Key': 'Above Average', 'SearchValue': 'AboveAverage' });
            }

            filterOptions.PriceAnalysis.push({ 'Key': 'No Price Analysis', 'SearchValue': 'None' });
        }

        

        function GetVehicleColors() {
            var deferred = $q.defer();

            var promise = $http({
                method: 'GET',
                url: mainUrl + 'Search/GetItemColors',

                headers: {
                    'Content-Type': 'application/json',
                    'Accept': '*/*',
                    'Accept-Language': 'en-US,en;q=0.8'

                }

            }).then(function (data) {
                if (data.data) {
                    data = data.data;
                }
                deferred.resolve(data);
            }).catch(function (data) {
                deferred.reject(data);
            });
            return deferred.promise;
        }

        function getInventoryMakes() {
            var deferred = $q.defer();

            var promise = $http({
                method: 'GET',
                url: mainUrl + 'Search/GetMakes',

                headers: {
                    'Content-Type': 'application/json',
                    'Accept': '*/*',
                    'Accept-Language': 'en-US,en;q=0.8'

                },

            }).then(function (data) {
                if (data.data) {
                    data = data.data;
                }
                deferred.resolve(data);
            }).catch(function (data) {
                deferred.reject(data);
            });
            return deferred.promise;
        }

        var getModels = function (make, isSpecial) {
            var deferred = $q.defer();

            var promise = $http({
                method: 'GET',
                url: mainUrl + 'Search/GetModels/?Make=' + make,
                headers: {
                    'Content-Type': 'application/json',
                    'Accept': '*/*',
                    'Accept-Language': 'en-US,en;q=0.8'

                }
            }).then(function (data) {
                if (data.data) {
                    data = data.data;
                }
                deferred.resolve(data);
            }).catch(function (data) {
                deferred.reject(data);
            });
            return deferred.promise;
        };

        var getTrims = function (make, model, newVehicle, isSpecial) {
            var deferred = $q.defer();

            var promise = $http({
                method: 'GET',
                url: mainUrl + 'Search/GetTrims/?Make=' + make + '&Model=' + model + '&NewVehicle=' + newVehicle,
                headers: {
                    'Content-Type': 'application/json',
                    'Accept': '*/*',
                    'Accept-Language': 'en-US,en;q=0.8'
                }
            }).then(function (data) {
                if (data.data) {
                    data = data.data;
                }
                deferred.resolve(data);
            }).catch(function (data) {
                deferred.reject(data);
            });
            return deferred.promise;
        };

        var toggleComplete;
        var toggleFilterListDisplay = function (obj, $event) {
            var deferred = $q.defer();
            var $e = $($event.currentTarget);

            var $i = $('.filter-toggle').find('i');
            var $div = $('.filter-toggle').find('div');
            var $filters = $('#filters');
            var $results = $('#search-results-list');
            var $loader = $('.loading-container');

            $('.filters-save').toggle();

            if ($filters.is(':hidden')) {
                $loader.hide();
                $results.fadeOut(150, function () {
                    $(this).addClass('hidden-xs');
                    $filters.removeClass('hidden-xs hidden-sm').fadeIn(250);
                    $div.text('done');
                    $i.removeClass('fa-sliders').addClass('fa-times');
                });
            } else {
                $filters.fadeOut(150, function () {
                    $(this).addClass('hidden-xs');
                    $results.removeClass('hidden-xs hidden-sm').fadeIn(250);
                    $div.text('filters');
                    $i.removeClass('fa-sliders').addClass('fa-sliders');
                    $loader.show();
                });
            }

            deferred.resolve(toggleComplete);
            toggleComplete = deferred.promise;
            return $q.when(toggleComplete);
        };


        return {
            GetMakes: retrieveMakes,
            GetModels: getModels,
            GetTrims: getTrims,            
            filterOptions: filterOptions,
            selectedFilters: selectedFilters,
            Init: init,
            filterLimits: filterLimits,
            ToggleFilterList: toggleFilterListDisplay
        };
    }]);

})(angular.module('AutoSMART.Web.Search'));
'use strict';

(function (module) {

    module.service('InventorySearchService', [
        '$http', '$q', '$location', 'InventoryFilterService', 'Config', 'ZipCodeService', function ($http, $q, $location, InventoryFilterService, Config, ZipCodeService) {

            var allVehicles = {
                SearchResults: [],
                Spotlights: [],
                SearchTotalCount: 0,
                HasAutoSmartXLive: false,
                dealerLogoUpdateDate: null,
                SearchTotalCountRemaining: 0,
                Features: []
            };
            var topCount = 15;
            function newSearchObj() {

                var newGuid = function () {
                    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
                        var r = Math.random() * 16 | 0, v = c == 'x' ? r : (r & 0x3 | 0x8);
                        return v.toString(16);
                    });
                };
                return {
                    IsLoadMoreSearch: false,
                    ItemType: 5, // Car
                    ItemTypes: [], // Default to Car
                    ClientWebsiteId: Config.ClientWebSiteID,
                    SearchString: null,
                    SearchSellersByMakeId: null,
                    Latitude: ZipCodeService.Location.Latitude || Config.CurrentLatitude,
                    Longitude: ZipCodeService.Location.Longitude || Config.CurrentLongitude,
                    DistanceRadius: Config.DefaultSearchDistance,
                    DistanceUnit: 0,
                    TopCount: topCount,
                    SortBy: 1,
                    Condition: "New",
                    UserGuid: newGuid(),
                    PageNumber: -1,
                    IsUserSearchTerm: false,
                    DoNotLogSearch: false,
                    LanguageId: 2,
                    AutoExtendDealerDistance: false,
                    RequireImage: false,
                    RequireNonZeroPrice: false,
                    OnlyPreferredDealers: false,
                    OnlyAutoPremierDealers: false,
                    OriginalSearchString: null,
                    PriceAnalysisList: [],
                    ActualSearchString: null,
                    TransactionGuid: newGuid(),
                    ProceedToUseSecondarySearch: false,
                    UseSecondarySearch: false,
                    TransactionStep: 1,
                    RawSearchString: null,
                    IsHidden: false,
                    NewChecked: true,
                    UsedChecked: true,
                    LoanRate: Config.Rate,
                    LoanTerm: Config.Term,
                    MakeModels: [],
                    MiscellaneousList: [],
                    ColorList: [],
                    UsageMax: 0,
                    IsNonTextBasedSearch: true,
                    BodyTypeList: [],
                    ExcludedItemIdList: [],
                    DealerClientCode: null,
                    IncludeSpotlightResults: true,
                    ShowSpecficInventoryCount: null,
                    SourcePlatform: 1,
                    SourceSection: 1,
                    ZipCode: "",
                    SearchRequestType: 1,
                    ExecutionTimeSearchQuery: null,
                    ExecutionTimeWholeSearch: null,
                    YearMin: 0,
                    YearMax: 0,
                    HasSingleOwnerHistory: false,
                    IsWithinSevenDaysOfStockedDate: false,
                    IsPriceDrop: false,
                    IsFeatureListingSearch: false,
                    FuelList: [],
                    DealerContactlessServices: [],
                    TransmissionList: [],
                    CylinderList: [],
                    DrivetrainList: [],
                    HwyMpgMin: null,
                    HwyMpgMax: null,
                    CUEnablePriceGuidance: Config.EnablePriceGuidance
                };
            }


            var getCurrentFilterOptions = function (switchOpposite) {
                var searchObj = newSearchObj();
                var condition = "Both";
                if (InventoryFilterService.selectedFilters.filters.Condition.length == 1) {
                    if (switchOpposite) {
                        if (InventoryFilterService.selectedFilters.filters.Condition[0] === "New") condition = "Used";
                        if (InventoryFilterService.selectedFilters.filters.Condition[0] === "Used") condition = "New";
                    }
                    else {
                        condition = InventoryFilterService.selectedFilters.filters.Condition[0];
                    }
                }
                searchObj.ZipCode = InventoryFilterService.selectedFilters.filters.ZipCode;
                searchObj.PageNumber = InventoryFilterService.selectedFilters.currentPage;
                searchObj.SortBy = InventoryFilterService.selectedFilters.filters.SortBy;
                searchObj.Condition = condition;
                searchObj.PriceAnalysisList = InventoryFilterService.selectedFilters.filters.PriceAnalysis;
                searchObj.DealerClientCode = InventoryFilterService.selectedFilters.filters.DealerClientCode;
                searchObj.ColorList = angular.copy(InventoryFilterService.selectedFilters.filters.Colors);
                searchObj.OnlyAutoPremierDealers = InventoryFilterService.selectedFilters.filters.ASXOnly;
                searchObj.MakeModels = angular.copy(InventoryFilterService.selectedFilters.filters.MakeModel);
                searchObj.Trims = angular.copy(InventoryFilterService.selectedFilters.filters.Trims);
                searchObj.HasSingleOwnerHistory = InventoryFilterService.selectedFilters.filters.Carfax1Owner;
                searchObj.IsWithinSevenDaysOfStockedDate = InventoryFilterService.selectedFilters.filters.NewlyListed;
                searchObj.IsPriceDrop = InventoryFilterService.selectedFilters.filters.PriceDrop;               
                searchObj.FuelList = angular.copy(InventoryFilterService.selectedFilters.filters.FuelOptions);
                searchObj.DealerContactlessServices = InventoryFilterService.selectedFilters.filters.DealerContactlessServices;
                searchObj.TransmissionList = angular.copy(InventoryFilterService.selectedFilters.filters.TransmissionType);
                searchObj.CylinderList = angular.copy(InventoryFilterService.selectedFilters.filters.Cylinder);
                searchObj.DrivetrainList = angular.copy(InventoryFilterService.selectedFilters.filters.DrivetrainType);
                searchObj.HwyMpgMin = InventoryFilterService.selectedFilters.filters.MPGMin;
                searchObj.HwyMpgMax = InventoryFilterService.selectedFilters.filters.MPGMax;
                
                if (InventoryFilterService.selectedFilters.filters.Distance && InventoryFilterService.selectedFilters.filters.Distance !== 0) {
                    searchObj.DistanceRadius = InventoryFilterService.selectedFilters.filters.Distance;
                }

                if (InventoryFilterService.selectedFilters.filters.MaxMiles != InventoryFilterService.filterLimits.MaxMileage) {
                    searchObj.UsageMax = InventoryFilterService.selectedFilters.filters.MaxMiles;
                }

                if (InventoryFilterService.selectedFilters.filters.MinPrice != InventoryFilterService.filterLimits.MinPrice) {
                    searchObj.PriceMin = InventoryFilterService.selectedFilters.filters.MinPrice;
                }

                if (InventoryFilterService.selectedFilters.filters.MaxPrice != InventoryFilterService.filterLimits.MaxPrice) {
                    searchObj.PriceMax = InventoryFilterService.selectedFilters.filters.MaxPrice;
                }

                if (InventoryFilterService.selectedFilters.filters.MinYear != InventoryFilterService.filterLimits.MinYearRange) {
                    searchObj.YearMin = InventoryFilterService.selectedFilters.filters.MinYear;
                }

                if (InventoryFilterService.selectedFilters.filters.MaxYear != InventoryFilterService.filterLimits.MaxYearRange) {
                    searchObj.YearMax = InventoryFilterService.selectedFilters.filters.MaxYear;
                }

                if (InventoryFilterService.selectedFilters.filters.IsSpecialty) {
                    var specialtyList = [];

                    if (InventoryFilterService.selectedFilters.filters.ItemType != 5) {
                        searchObj.ItemType = InventoryFilterService.selectedFilters.filters.ItemType;
                        specialtyList = [InventoryFilterService.selectedFilters.filters.ItemType];
                    } else if (InventoryFilterService.selectedFilters.filters.VehicleType.length === 0) {
                        angular.forEach(InventoryFilterService.filterOptions.VehicleType, function (vehicleType) {
                            specialtyList.push(vehicleType.SearchValue);
                        });
                    } else {
                        angular.forEach(InventoryFilterService.selectedFilters.filters.VehicleType, function (vehicleType) {
                            specialtyList.push(vehicleType);
                        });
                    }
                    searchObj.ItemTypes = specialtyList;
                } else {
                    //car vehicle types
                    searchObj.ItemTypes = [5];
                    angular.forEach(InventoryFilterService.selectedFilters.filters.VehicleType, function (vehicleType) {
                        if (vehicleType.toLowerCase() === "electric") {
                            searchObj.MiscellaneousList.push("Electric");
                            searchObj.MiscellaneousList.push("Hybrid");
                        } else {
                            searchObj.BodyTypeList.push(vehicleType);
                        }
                    });
                }

                angular.forEach(InventoryFilterService.selectedFilters.filters.Makes, function (make) {
                    var index = -1;
                    for (var i = 0, len = searchObj.MakeModels.length; i < len; i++) {
                        if (searchObj.MakeModels[i].Make === make) {
                            index = i;
                            break;
                        }

                    }
                    if (index == -1) {
                        var makeObj = {
                            Make: make,
                            Model: ""
                        }
                        searchObj.MakeModels.push(makeObj);
                    }
                });

                angular.forEach(InventoryFilterService.selectedFilters.filters.MakeModel, function (makeModel) {
                    var index = -1;
                    for (var i = 0, len = searchObj.Trims.length; i < len; i++) {
                        if (searchObj.Trims[i].Make === makeModel.Make &&
                            searchObj.Trims[i].Model === makeModel.Model) {
                            index = i;
                            break;
                        }

                    }
                    if (index == -1) {
                        var makeModelObj = {
                            Make: makeModel.Make,
                            Model: makeModel.Model,
                            Trim: ""
                        };
                        searchObj.Trims.push(makeModelObj);
                    }
                });

                return searchObj;
            };

            var setFeaturedListingOptions = function(searchObj) {
                //featured listings require vehicles from preferred plus dealers and market pricing
                searchObj.OnlyAutoPremierDealers = true;
                searchObj.IsFeatureListingSearch = true;
                searchObj.TopCount = 500;

                if (searchObj.PriceAnalysisList.length === 0) {
                    switch (searchObj.Condition) {
                        case 'Used':
                            searchObj.PriceAnalysisList = ['Great', 'Fair'];
                            break;
                        case 'New':
                            searchObj.PriceAnalysisList = ['Great', 'Fair', 'None'];
                            break;
                    }
                }
            };

            var retrieveVehicles = function (page) {
                InventoryFilterService.selectedFilters.currentPage = (page) ? page : 0;
                InventoryFilterService.filterOptions.VisibleVehicles = 15;
                var searchObj = getCurrentFilterOptions();
                var json = JSON.stringify(searchObj);

                //Remove hash so on filter change, it goes back to page 1
                if (InventoryFilterService.selectedFilters.currentPage == 0) $location.hash('');

                var deferred = $q.defer();
                var link = Config.BaseDirectory + "/SearchService/PostSearch"; 
                
                var promise = $http({
                    method: 'POST',
                    url: link,

                    headers: {
                        'Content-Type': 'application/json',
                        'Accept': '*/*',
                        //'Accept-Encoding': 'gzip, deflate',
                        'Accept-Language': 'en-US,en;q=0.8'

                    },
                    data: json,
                }).then(function (data) {
                    if (data.data) {
                        data = data.data;
                    }
                    allVehicles.SearchResults = data.SearchResults;
                    allVehicles.Spotlights = data.SpotLightResults;
                    allVehicles.SearchTotalCount = data.SearchTotalCount;
                    allVehicles.HasAutoSmartXLive = data.HasAutoSmartXLive;
                    allVehicles.Loading = false;
                    allVehicles.dealerLogoUpdateDate = (!data.SearchResults || data.SearchResults.length === 0) ? null : data.SearchResults[0].DealerLogoUpdateDate;

                    deferred.resolve(data);
                }).catch(function (data) {
                    allVehicles.Loading = false;
                    deferred.reject(data);
                });
                return deferred.promise;
            };

            var remainingCount = function () {
                var searchObj = getCurrentFilterOptions(true);
                var json = JSON.stringify(searchObj);

                var deferred = $q.defer();
                var link = Config.BaseDirectory + "/SearchService/PostSearch";

                var promise = $http({
                    method: 'POST',
                    url: link,

                    headers: {
                        'Content-Type': 'application/json',
                        'Accept': '*/*',
                        'Accept-Language': 'en-US,en;q=0.8'
                    },
                    data: json,
                }).then(function (data) {
                    if (data.data) {
                        data = data.data;
                    }
                    allVehicles.SearchTotalCountRemaining = data.SearchTotalCount;
                    deferred.resolve(data);
                }).catch(function (data) {
                    allVehicles.Loading = false;
                    deferred.reject(data);
                });
                return deferred.promise;
            };

            var loadMore = function (page) {
                InventoryFilterService.selectedFilters.currentPage = page - 1;

                var searchObj = getCurrentFilterOptions();
                searchObj.IsLoadMoreSearch = true;
                var json = JSON.stringify(searchObj);                
                var deferred = $q.defer();


                var link = Config.BaseDirectory + "/SearchService/PostSearchMore";

                var promise = $http({
                    method: 'POST',
                    url: link,

                    headers: {
                        'Content-Type': 'application/json',
                        'Accept': '*/*',
                        //'Accept-Encoding': 'gzip, deflate',
                        'Accept-Language': 'en-US,en;q=0.8'

                    },
                    data: json
                }).then(function (data) {
                    if (data.data) {
                        data = data.data;
                    }
                    allVehicles.SearchResults = data.SearchResults; //Do not add to array, just get 1 page of results
                    deferred.resolve(data);
                }).catch(function (data) {
                    deferred.reject(data);
                });
                return deferred.promise;
            };


            var getInventoryCount = function (year, make, model) {
                var searchObj = newSearchObj();
                searchObj.ItemTypes.push(5);
                searchObj.YearMax = year;
                searchObj.YearMin = year;
                searchObj.DistanceRadius = 100;
                var makeModel = {
                    Make: make,
                    Model: model
                };
                searchObj.MakeModels.push(makeModel);
                var json = JSON.stringify(searchObj);
                var deferred = $q.defer();


                var link = Config.BaseDirectory + "/SearchService/PostSearch";

                var promise = $http({
                    method: 'POST',
                    url: link,

                    headers: {
                        'Content-Type': 'application/json',
                        'Accept': '*/*',
                        //'Accept-Encoding': 'gzip, deflate',
                        'Accept-Language': 'en-US,en;q=0.8'

                    },
                    data: json,
                }).then(function (data) {
                    if (data.data) {
                        data = data.data;
                    }
                    deferred.resolve(data);

                }).catch(function (data) {
                    deferred.reject(data);

                });
                return deferred.promise;
            }

            var retrieveFeaturedVehicles = function () {
                var deferred = $q.defer();
                var searchObj = getCurrentFilterOptions();

                if (searchObj.DealerClientCode) {
                    return deferred.promise;
                }

                setFeaturedListingOptions(searchObj);
                var json = JSON.stringify(searchObj);

                
                var link = Config.BaseDirectory + "/SearchService/PostSearch";

                var promise = $http({
                    method: 'POST',
                    url: link,

                    headers: {
                        'Content-Type': 'application/json',
                        'Accept': '*/*',
                        'Accept-Language': 'en-US,en;q=0.8'
                    },
                    data: json
                }).then(function (data) {
                    if (data.data) {
                        data = data.data;
                    }
                    allVehicles.Features = data.SearchResults;
                    deferred.resolve(data);
                }).catch(function (data) {
                    deferred.reject(data);
                });
                return deferred.promise;
            };

            return {
                RetrieveVehicles: retrieveVehicles,
                allVehicles: allVehicles,
                RetrieveMoreVehicles: loadMore,
                GetInventoryCount: getInventoryCount,
                RemainingCount: remainingCount,
                RetrieveFeaturedVehicles: retrieveFeaturedVehicles
            }
        }
    ]);
})(angular.module('AutoSMART.Web.Search'));
'use strict';

(function (module) {
    module.service('DedicatedDealerHeaderService', ['$http', '$q', 'InventoryFilterService', 'InventorySearchService', function ($http, $q, InventoryFilterService, InventorySearchService) {

        var mainUrl = window.location.protocol + '//' + window.location.host + '/';
        var dedicatedDealerContent = {
            AutoPremierContact: "",
            AutoPremierContactPhone: null,
            AutoPremierContactTitle: "",
            City: "",
            ClientName: "",
            DealerPhotoURL: "",
            ClientCode: "",
            HasAutoPremierContact: null,
            IsAutoSmartXLive: null,
            LogoURL: "",
            Rating: null,
            TotalLifetimeReviews: null,
            State: "",
            Street: "",
            Zip: "",
            CreditUnionName: "",
            Stock: null,
            Distance: null,
            StockRemaining: null,
            DealerPhone: "",
            HasHomeDeliverySales: false,
            HasHomePickupAndDeliveryService: false,
            HasHomeTestDrives: false,
            HasNoContactTransactions: false,
            HasVirtualAppointments: false,
            TotalInventoryCount: 0,
            UsedInventoryCount: 0,
            NewInventoryCount: 0
        };

        var init = function () {
            return $q.all([
                getDedicatedDealerContent()
                    .then(function (data) {
                        if (data.data) {
                            data = data.data;
                        }
                        dedicatedDealerContent.AutoPremierContact = data.AutoPremierContact;
                        dedicatedDealerContent.AutoPremierContactPhone = data.AutoPremierContactPhone;
                        dedicatedDealerContent.AutoPremierContactTitle = data.AutoPremierContactTitle;
                        dedicatedDealerContent.City = data.City;
                        dedicatedDealerContent.ClientCode = data.ClientCode;
                        dedicatedDealerContent.ClientName = data.ClientName;
                        dedicatedDealerContent.DealerPhotoURL = data.DealerPhotoURL;
                        dedicatedDealerContent.HasAutoPremierContact = data.HasAutoPremierContact;
                        dedicatedDealerContent.IsAutoSmartXLive = data.IsAutoSmartXLive;
                        dedicatedDealerContent.LogoURL = data.LogoURL;
                        dedicatedDealerContent.Rating = data.Rating;
                        dedicatedDealerContent.TotalLifetimeReviews = data.TotalLifetimeReviews;
                        dedicatedDealerContent.State = data.State;
                        dedicatedDealerContent.Street = data.Street;
                        dedicatedDealerContent.Zip = data.Zip;
                        dedicatedDealerContent.DealerPhone = data.Phone;
                        dedicatedDealerContent.HasHomeDeliverySales = data.HasHomeDeliverySales;
                        dedicatedDealerContent.HasHomePickupAndDeliveryService = data.HasHomePickupAndDeliveryService;
                        dedicatedDealerContent.HasHomeTestDrives = data.HasHomeTestDrives;
                        dedicatedDealerContent.HasNoContactTransactions = data.HasNoContactTransactions;
                        dedicatedDealerContent.HasVirtualAppointments = data.HasVirtualAppointments;
                    }
                ),
                getInventoryCount()
            ]);
        };

        function getDedicatedDealerContent() {
            var deferred = $q.defer();
            var dealerCode = (InventoryFilterService.selectedFilters.filters.DealerClientCode === null) ? '' : InventoryFilterService.selectedFilters.filters.DealerClientCode;
            var practice = InventorySearchService;
            var promise = $http({
                method: 'GET',
                url: mainUrl + '/Search/GetDealerDetails?dealerclientcode=' + dealerCode + '&dealerlogodate=' + InventorySearchService.allVehicles.dealerLogoUpdateDate,

                headers: {
                    'Content-Type': 'application/json',
                    'Accept': '*/*',
                    'Accept-Language': 'en-US,en;q=0.8'
                }
            }).then(function (data) {
                if (data.data) {
                    data = data.data;
                }
                deferred.resolve(data);
            }).catch(function (data) {
                deferred.reject(data);
            });
            return deferred.promise;
        };

        var getInventoryCount = function () {
            var deferred = $q.defer();
            var dealerCode = (InventoryFilterService.selectedFilters.filters.DealerClientCode === null) ? '' : InventoryFilterService.selectedFilters.filters.DealerClientCode;
            var link = mainUrl + "/SearchService/GetDealerInventoryCount?clientcode=" + dealerCode;

            var promise = $http({
                method: 'GET',
                url: link,

                headers: {
                    'Content-Type': 'application/json',
                    'Accept': '*/*',
                    'Accept-Language': 'en-US,en;q=0.8'
                },
            }).then(function (data) {
                if (data.data) {
                    data = data.data;
                }
                dedicatedDealerContent.TotalInventoryCount = data.TotalInventoryCount;
                dedicatedDealerContent.UsedInventoryCount = data.UsedInventoryCount;
                dedicatedDealerContent.NewInventoryCount = data.NewInventoryCount
                deferred.resolve(data);
            }).catch(function (data) {
                deferred.reject(data);
            });
            return deferred.promise;
        };

        return {
            Init: init,
            DedicatedDealerContent: dedicatedDealerContent
        }
    }]);

})(angular.module('AutoSMART.Web.Search'));
"use strict";

angular.module('AutoSMART.Web.Search')
    .filter('maxprice', function () {
        return function (priceVal) {
            if (priceVal == "$100,000.00") {
                return priceVal + "+";
            }
            return priceVal;
        };
    });
"use strict";

angular.module('AutoSMART.Web.Search')
    .filter('distance', function () {
        return function (distanceVal) {
            if(parseInt(distanceVal) > 250) {
                return "NATIONWIDE";
            }
            return distanceVal + " MILES OF";
        };
    });
"use strict";

(function (module) {

    module.component('inventorycomponent', {

        controller: ["$scope", "$stateParams", "$location", "InventoryFilterService", "InventorySearchService", "Config", "CalculatorService", "$cookies", "$uibModal", "DedicatedDealerHeaderService", "insights", 'AmplitudeService',
            function ($scope, $stateParams, $location, InventoryFilterService, InventorySearchService, Config, CalculatorService, $cookies, $uibModal, DedicatedDealerHeaderService, insights, AmplitudeService) {
                var ctrl = this;
                var priceincrement = 1000;
                var minprice = 0;
                var maxprice = 100000 + priceincrement;

                ctrl.Loading = true;
                ctrl.showPaymentCalculator = true;
                ctrl.screenWidth = window.innerWidth;
                ctrl.screenHeight = window.innerHeight;

                ctrl.openAutomatically = function () {
                    if (ctrl.allVehicles.HasAutoSmartXLive && !InventoryFilterService.selectedFilters.filters.IsSpecialty) {
                        var hasCookie = $cookies.get("interstitialModalViewed");
                        if (!hasCookie) {
                            var interstitial = $uibModal.open({
                                animation: true,
                                ariaDescribedBy: 'interstitial-modal-body',
                                templateUrl: '/app/Common/views/_InterstitialModal.html',
                                component: 'interstitialmodal',
                                scope: $scope,
                                windowClass: 'interstitial-modal-content'
                            });
                            $scope.Interstitial = interstitial;
                        }
                    }
                };

                ctrl.$onInit = function () {
                    var getsearchvalue = $location.$$search;
                    var model = "All";
                    var searchby = localStorage.getItem("tabname") ? localStorage.getItem("tabname") : 'make & model or vehicle type';
                    var condition = getsearchvalue.Condition ? getsearchvalue.Condition : "new, used";
                    var make = getsearchvalue.Makes ? getsearchvalue.Makes : "All";
                    if (searchby == 'make & model' && getsearchvalue.MakeModel) {
                        var value = getsearchvalue.MakeModel.split("|");
                        make = value[0];
                        model = value[1];
                    }
                    AmplitudeService.logEvent('Search Results Page Viewed',
                        {
                            'searched by': searchby,
                            'make': make,
                            'model': model,
                            'vehicle type': condition
                        });
                    var correlationId = insights.randomString(5);
                    insights.logEvent("Search Result Page load start", { 'tenentId': Config.ClientCode, "correlationId": correlationId });
                    document.title = "AutoSMART - Search for Cars";
                    ctrl.selectedFilters = InventoryFilterService.selectedFilters;
                    var currentPage = ($location.hash()) ? $location.hash().split('=')[1] - 1 : 0;
                    InventoryFilterService.Init('new').then(function () {

                        ctrl.filterOptions = InventoryFilterService.filterOptions;

                        if ($stateParams.dealerclientcode) {
                            InventoryFilterService.selectedFilters.filters.DealerClientCode = $stateParams.dealerclientcode;
                        }

                        InventorySearchService.RetrieveFeaturedVehicles();
                        InventorySearchService.RetrieveVehicles(currentPage).then(function () {
                            ctrl.allVehicles = InventorySearchService.allVehicles;
                            ctrl.openAutomatically();

                            var dealerCode = (InventoryFilterService.selectedFilters.filters.DealerClientCode === null) ? '' : InventoryFilterService.selectedFilters.filters.DealerClientCode;
                            if (dealerCode) {
                                DedicatedDealerHeaderService.Init().then(function () {
                                    $scope.DealerCode = InventoryFilterService.selectedFilters.filters.DealerClientCode;
                                    ctrl.dedicatedDealerContent = DedicatedDealerHeaderService.DedicatedDealerContent;
                                    ctrl.dedicatedDealerContent.Stock = ctrl.allVehicles.SearchTotalCount;
                                    $scope.CreditUnionName = Config.ClientName;
                                    $scope.TotalStock = InventorySearchService.allVehicles.SearchTotalCount;
                                    $scope.DealershipDistance = (InventorySearchService.allVehicles.SearchResults.length === 0) ? 0 : InventorySearchService.allVehicles.SearchResults[0].Distance;
                                    $scope.DealershipRating = (InventorySearchService.allVehicles.SearchResults.length === 0) ? 0 : InventorySearchService.allVehicles.SearchResults[0].Rating;
                                    $scope.IsPreferred = (InventorySearchService.allVehicles.SearchResults.length === 0) ? 0 : InventorySearchService.allVehicles.SearchResults[0].IsPreferred;
                                    InventorySearchService.RemainingCount().then(function () {
                                        ctrl.dedicatedDealerContent.StockRemaining = ctrl.allVehicles.SearchTotalCountRemaining;
                                    });
                                    ctrl.Loading = false;
                                });

                            }
                            else {
                                ctrl.Loading = false;
                            }
                            insights.logEvent('Search Results Page load finish', { 'tenentId': Config.ClientCode, "correlationId": correlationId });
                        });

                        $scope.setupFilters();
                    });

                    CalculatorService.Init().then(function () {
                        ctrl.calcContent = CalculatorService.CalcContent;
                    });
                };

                $scope.setupFilters = function () {
                    window.setTimeout(function () {
                        $('.filter .header .toggler').on('click', function () {
                            $scope.toggleFilter(this);                            
                        });
                        $('.filter .header .toggler').on('keypress', function (evt) {                            
                            evt.preventDefault();
                            var keyCode = 0;
                            if (evt.keyCode) keyCode = evt.keyCode;
                            else if (evt.which) keyCode = evt.which;
                            if (keyCode === 13 || keyCode === 32)
                                $scope.toggleFilter(this);                                                            
                        });
                        $('.scrollbar-light').scrollbar();
                        $scope.setUpFilterDisplay();
                    }, 100);
                };

                $scope.setUpFilterDisplay = function () {
                    var search = $location.search();
                    var list = ['condition-filter', 'vehicletype-filter', 'make-filter', 'model-filter', 'trim-filter',
                        'color-filter', 'features-filter', 'engine-drivetrain-filter', 'fuel-filter'];

                    angular.forEach(search, function (value, key) {
                        var index = -1;
                        if (key.toLowerCase() === 'condition') {
                            index = list.indexOf('condition-filter');
                            if (index !== -1) {
                                list.splice(index, 1);
                            }
                        }

                        if (key.toLowerCase() === 'makes') {
                            index = list.indexOf('make-filter');
                            if (index !== -1) {
                                list.splice(index, 1);
                            }
                        }

                        if (key.toLowerCase() === 'makemodel') {
                            index = list.indexOf('model-filter');
                            if (index !== -1) {
                                list.splice(index, 1);
                            }
                        }

                        if (key.toLowerCase() === 'vehicletype') {
                            index = list.indexOf('vehicletype-filter');
                            if (index !== -1) {
                                list.splice(index, 1);
                            }
                        }

                        if (key.toLowerCase() === 'colors') {
                            index = list.indexOf('color-filter');
                            if (index !== -1) {
                                list.splice(index, 1);
                            }
                        }

                        if (key.toLowerCase() === 'carfax1owner') {
                            index = list.indexOf('features-filter');
                            if (index !== -1) {
                                list.splice(index, 1);
                            }
                        }

                        if (key.toLowerCase() === 'newlylisted') {
                            index = list.indexOf('features-filter');
                            if (index !== -1) {
                                list.splice(index, 1);
                            }
                        }

                        if (key.toLowerCase() === 'pricedrop') {
                            index = list.indexOf('features-filter');
                            if (index !== -1) {
                                list.splice(index, 1);
                            }
                        }

                        if (key.toLowerCase() === 'trims') {
                            index = list.indexOf('trim-filter');
                            if (index !== -1) {
                                list.splice(index, 1);
                            }
                        }

                        if (key.toLowerCase() === 'transmissiontype' || key.toLowerCase() === 'cylinder' || key.toLowerCase() === 'drivetraintype') {
                            index = list.indexOf('engine-drivetrain-filter');
                            if (index !== -1) {
                                list.splice(index, 1);
                            }
                        }

                        if (key.toLowerCase() === 'fueloptions' || key.toLowerCase() === 'mpgmin' || key.toLowerCase() === 'mpgmax') {
                            index = list.indexOf('fuel-filter');
                            if (index !== -1) {
                                list.splice(index, 1);
                            }
                        }
                    });

                    angular.forEach(list, function (value, key) {
                        var filterElem = "#" + value;
                        $(filterElem).find('.toggler').addClass('toggler-down').removeClass('toggler-up');
                        $(filterElem + " .items").css("height", "0");
                    });
                };

                var getItemsHeight = function ($items) {
                    var goToHeight = 0;
                    var stopCount = 11;
                    $items.find('li').each(function (idx) {
                        if (idx <= stopCount) {
                            goToHeight += $(this).outerHeight();
                        }
                    });
                    return goToHeight;
                };

                $scope.toggleFilter = function (elem) {
                    var $elem = $(elem);
                    var $items = $elem.parents('.filter').find('.items');
                    var goToHeight = 0;

                    if ($items.height() === 0) {
                        var $sliderControl = $items.find('.slider-control');
                        if ($sliderControl.length > 0) {
                            if ($sliderControl.attr('data-toggle-height')) {
                                goToHeight = $sliderControl.data('toggle-height');
                            }
                            else {
                                goToHeight = 85;
                            }
                        }
                        else {
                            if ($items.attr('data-max-height')) {
                                goToHeight = $items.data('max-height');
                            }
                            else {
                                goToHeight = 275;
                            }
                        }
                    }

                    $items.velocity({
                        height: goToHeight
                    }, 500, function () {
                        if ($elem.hasClass('toggler-down')) {
                            $elem.addClass('toggler-up').removeClass('toggler-down');
                        } else {
                            $elem.addClass('toggler-down').removeClass('toggler-up');
                        }

                    }, 'easeInOutQuad');
                };

                $scope.updateQueryString = function (fld) {
                    if (typeof ctrl.selectedFilters.filters[fld] === 'boolean') {
                        if (ctrl.selectedFilters.filters[fld] === false)
                            $location.search(fld, null);
                        else
                            $location.search(fld, ctrl.selectedFilters.filters[fld].toString());
                    } else if (ctrl.selectedFilters.filters[fld] !== '') {
                        $location.search(fld, ctrl.selectedFilters.filters[fld]);
                    } else {
                        $location.search(fld, null);
                    }
                };

                $scope.toggleFilterListDisplay = function (obj, $event) {
                    InventoryFilterService.ToggleFilterList(obj, $event).then(function () {
                        $scope.$broadcast('rzSliderForceRender');
                    });
                };

            }],
        templateUrl: UrlContent('/App/SearchResult/Views/InventoryComponent.html?d')
    });
})(angular.module('AutoSMART.Web.Search'));
/// <reference path="LocationComponent.js" />
"use strict";

(function (module) {

    module.component('inventoryfilterscomponent', {
        bindings: {
            isloading: '='
        },
        controller: ["$scope", "$location", "$timeout", "InventorySearchService", "InventoryFilterService", "Config", "$uibModal", "$cookies", "ZipCodeService", "NotificationService", "$rootScope", function ($scope, $location, $timeout, InventorySearchService, InventoryFilterService, Config, $uibModal, $cookies, ZipCodeService, NotificationService, $rootScope) {
            var ctrl = this;
            ctrl.currentMake;
            ctrl.currentModel;
            ctrl.currentTrim;

            $scope.contactservicemodelclicked = function () {                               
                var modalInstance = $uibModal.open({ 
                    templateUrl: '/App/SearchResult/Views/DealerContactlessServiceModel.html',
                    scope: $scope,
                    windowClass: 'dealer-contactless-services-modal'
                });
                $scope.modalInstance = modalInstance;                
            }
            $scope.cancelModal = function () {
                $scope.modalInstance.dismiss('cancel');
            };
            var svgColor = (!Config.SecondaryColor || Config.SecondaryColor.toUpperCase() === "#FFF" || Config.SecondaryColor.toUpperCase() === "#FFFFFF") ? Config.PrimaryColor : Config.SecondaryColor;
            ctrl.svgcontent = {
                TextColor : svgColor,
                ShieldColor: svgColor
            };

            var scrollToTop = function (offset) {
                if (window.pageYOffset > 110) {
                    $('html, body').animate({ scrollTop: offset }, { duration: 1500, queue: false }, "easeInExpo");
                }
            };

            var recalculateModelHeights = function () {
                var targetHeight = 0;
                var $targ = $('div[data-item-type="models"]');

                $targ.find('b.make-name').each(function () {
                    targetHeight += $(this).height();
                });

                $targ.find('ul').each(function () {
                    $(this).find('li').each(function (idx) {

                    });
                });

                $targ.scrollbar();
            };

            var recalculateTrimHeights = function () {
                var targetHeight = 0;
                var $targ = $('div[data-item-type="trims"]');

                $targ.find('b.model-name').each(function () {
                    targetHeight += $(this).height();
                });

                $targ.find('ul').each(function () {
                    $(this).find('li').each(function (idx) {
                    });

                });

                $targ.scrollbar();
            };

            var validatePriceRange = function(elem) {
                var max = ctrl.selectedFilters.filters["MaxPrice"];
                var min = ctrl.selectedFilters.filters["MinPrice"];
                if (max <= min && min != 100000) {
                    max = min + 1000;
                }

                if (min >= max && min != 100000) {
                    min = max - 1000;
                }

                ctrl.selectedFilters.filters["MinPrice"] = min;
                ctrl.selectedFilters.filters["MaxPrice"] = max;
            }

            //Get URL variables
            var url = $location.search();

            // Grab the filter options
            $scope.filters = InventoryFilterService.filterOptions;

            var runSetMenu = true;

            //Logic for when to run setSelectMenus function
            var setMenu = function (makeLength, modelLength, trimLength) {

                if (!url.Makes) {
                    return true; //No makes present in the URL
                } else if (url.Makes && makeLength > 1) {
                    if (!url.MakeModel) { //No Model present in the URL
                        return true;
                    } else if(url.MakeModel && modelLength > 1){
                        if (!url.Trims) { //No Trim in the URL
                            return true;
                        } else if(url.Trims && trimLength > 1) {
                            return true;
                        }
                    }
                }
                return false;
            }
            // Watch for changes in the filters object  
            $scope.$watch('filters', function (newValue, oldValue, scope) {
                if (setMenu($scope.filters.Makes.length,
                    $scope.filters.MakeModel.length,
                    $scope.filters.Trims.length)
                    && runSetMenu) {
                    setSelectMenus();
                }
            }, true);

            // Set the selected prop on the make, model and trim dropdown menus based on URL values
            var setSelectMenus = function () {
                runSetMenu = false;

                //Add All Makes to the Makes Array
                if (ctrl.filterOptions.Makes.indexOf('All Makes') === -1) ctrl.filterOptions.Makes.unshift('All Makes');

                // Add 'All' to Models and Trim Dropdowns
                if (ctrl.filterOptions.MakeModel.length === 0 || ctrl.filterOptions.MakeModel[0].Model !== "All Models") ctrl.filterOptions.MakeModel.unshift({ Make: '', Model: "All Models" });
                if (ctrl.filterOptions.Trims.length === 0 || ctrl.filterOptions.Trims[0].Trim !== "All Trims") ctrl.filterOptions.Trims.unshift({ Make: '', Model: '', Trim: "All Trims" });

                var urlMakes = (url.Makes) ? url.Makes.toString() : false;
                var makeIndex = (urlMakes && ctrl.filterOptions.Makes.indexOf(urlMakes) > -1) ? ctrl.filterOptions.Makes.indexOf(urlMakes) : 0; //Default to 0
                var modelIndex = 0; // Default to 0
                var trimIndex = 0; // Default to 0
                var urlModels = "All Models";
                var urlTrims = "All Trims";

                //Set the Model Select <option>
                if (makeIndex > 0 && url.MakeModel) {
                    urlModels = (url.MakeModel.split('|'));

                    urlModels = urlModels[1].toString();
                    for (var i = ctrl.filterOptions.MakeModel.length - 1; i > 0; i--) {
                        if (ctrl.filterOptions.MakeModel[i].Model === urlModels) {
                            modelIndex = i;
                            break;
                        }
                    }

                    //Set the Trim Select <option>
                    if (url.Trims) {
                        urlTrims = (url.Trims.split('|'));
                        urlTrims = urlTrims[2].toString();

                        for (var i = ctrl.filterOptions.Trims.length - 1; i > 0; i--) {
                            if (ctrl.filterOptions.Trims[i].Trim === urlTrims) {
                                trimIndex = i;
                                break;
                            }
                        }
                    }
                }
                $scope.selectedMake = ctrl.filterOptions.Makes[makeIndex];
                $scope.selectModel = ctrl.filterOptions.MakeModel[modelIndex];
                $scope.selectTrim = ctrl.filterOptions.Trims[trimIndex];
                ctrl.currentModel = $scope.selectModel.Model;
                ctrl.currentMake = $scope.selectedMake;
                ctrl.currentTrim = $scope.selectTrim.Trim;
                $scope.selectMPGMin = InventoryFilterService.selectedFilters.filters.MPGMin;
                $scope.selectMPGMax = InventoryFilterService.selectedFilters.filters.MPGMax;
            }

            ctrl.$onInit = function () {
                ctrl.selectedFilters = InventoryFilterService.selectedFilters;
                ctrl.filterOptions = $scope.filters;
                ctrl.allVehicles = InventorySearchService.allVehicles;
                ctrl.filterLimits = InventoryFilterService.filterLimits;
                ctrl.IsSpecialty = ctrl.selectedFilters.filters.IsSpecialty;
                // save default zipcode provided by URL
                ZipCodeService.Init()
                    .then(function () {
                        if (url.ZipCode) {
                            ZipCodeService.SaveZipCode(url.ZipCode);
                        }
                        ctrl.ZipCode = ZipCodeService.Location.CurrentZipCode;
                    });

                $scope.pricerange = {
                    options: {
                        id: 'priceRange',
                        floor: ctrl.filterLimits.MinPrice,
                        ceil: ctrl.filterLimits.MaxPrice,
                        step: ctrl.filterLimits.PriceIncrement,
                        noSwitching: true,
                        hidePointerLabels: true,
                        hideLimitLabels: true,
                        keyboardSupport:true,
                        ariaLabel: 'Price Range (lower limit)',
                        ariaLabelHigh: 'Price Range (upper limit)',
                        onEnd: function (e) {
                            validatePriceRange(this);
                            updateQueryString('MinPrice');
                            updateQueryString('MaxPrice');
                            DoSearch();
                        }
                    }
                };

                $scope.yearrange = {
                    options: {
                        floor: ctrl.filterLimits.MinYearRange,
                        ceil: ctrl.filterLimits.MaxYearRange,
                        step: ctrl.filterLimits.YearIncrement,
                        noSwitching: true,
                        hidePointerLabels: true,
                        hideLimitLabels: true,
                        keyboardSupport: true,
                        ariaLabel: 'Year Range (lower limit)',
                        ariaLabelHigh: 'Year (upper limit)',
                        onEnd: function (e) {
                            updateQueryString('MinYear');
                            updateQueryString('MaxYear');
                            DoSearch();
                        }
                    }
                };

                $scope.maxmiles = {
                    options: {
                        floor: ctrl.filterLimits.MinMileage,
                        ceil: ctrl.filterLimits.MaxMileage,
                        showSelectionBar: true,
                        step: ctrl.filterLimits.MileageIncrement,
                        hidePointerLabels: true,
                        hideLimitLabels: true,
                        keyboardSupport: true,
                        ariaLabel: 'Maximum Mileage',
                        onEnd: function (e) {
                            updateQueryString('MaxMiles');
                            DoSearch();
                        }
                    }
                };

                $scope.distance = {
                    options: {
                        showSelectionBar: true,
                        floor: ctrl.filterLimits.MinDistanceRange,
                        ceil: ctrl.filterLimits.MaxDistanceRange,
                        step: ctrl.filterLimits.DistanceIncrement,
                        hidePointerLabels: true,
                        hideLimitLabels: true,
                        keyboardSupport: true,
                        ariaLabel: 'Search Within ' + ctrl.filterLimits.MaxDistanceRange + ' Miles of ' + url.ZipCode,
                        onEnd: function (e) {
                            updateQueryString("Distance");
                            DoSearch();
                        }
                    }
                };
            };


            ctrl.reset = function () {
                InventorySearchService.allVehicles = {
                    SearchResults: [],
                    Spotlights: []
                };
                ctrl.allVehicles = {
                    SearchResults: [],
                    Spotlights: []
                };
                ctrl.allVehicles.SearchResults = [];
            }

            ctrl.toggleFilterTrims = function (make, model, trim, oldTrim) {

                ctrl.selectedFilters.filters.Trims = [];
             
                var trimObj =
                {
                    Make: make,
                    Model: model,
                    Trim: trim
                };                

                if(make !== '' && model !== '' && trim !== 'All Trims') ctrl.selectedFilters.filters.Trims.push(trimObj);
                updateTrimQueryString(ctrl.currentMake, ctrl.currentModel, trim);
                DoSearch();

            };

            ctrl.openAutomatically = function () {
                if (ctrl.allVehicles.HasAutoSmartXLive && !InventoryFilterService.selectedFilters.filters.IsSpecialty) {
                    var hasCookie = $cookies.get("interstitialModalViewed");
                    if (!hasCookie) {
                        var interstitial = $uibModal.open({
                            animation: true,
                            ariaDescribedBy: 'interstitial-modal-body',
                            templateUrl: '/app/Common/views/_InterstitialModal.html',
                            component: 'interstitialmodal',
                            scope: $scope,
                            windowClass: 'interstitial-modal-content'
                        });
                        $scope.Interstitial = interstitial;
                    }
                }
            };

            ctrl.open = function () {
                var interstitial = $uibModal.open({
                    animation: true,
                    ariaDescribedBy: 'interstitial-modal-body',
                    templateUrl: '/app/Common/views/_InterstitialModal.html',
                    component: 'interstitialmodal',
                    scope: $scope,
                    windowClass: 'interstitial-modal-content'
                });
                $scope.Interstitial = interstitial;
                };

            ctrl.textBoxModels = function () {
                //we shouldn't need the parameters if textbox correctly assigns to selectedFilter model
            }

            ctrl.toggleMakeItem = function (filterName, filterValue, oldFilterValue) {
                updateTrimQueryString(filterValue, '', '');
                updateMakeModelQueryString(filterValue, '');
                ctrl.currentMake = filterValue;

                // Reset Model Array
                ctrl.selectedFilters.filters.Makes = [];
                ctrl.filterOptions.MakeModel = [];
                if (filterValue !== 'All Makes') {
                    InventoryFilterService.GetModels(filterValue)
                        .then(function (data) {
                            if (data.data) {
                                data = data.data;
                            }
                            angular.forEach(data,
                                function (model) {
                                    var makeModel = {
                                        Make: filterValue,
                                        Model: model.Model
                                    };
                                    ctrl.filterOptions.MakeModel.push(makeModel);
                                });

                        }).finally(function () { });
                    ctrl.selectedFilters.filters.Makes.push(filterValue);
                }

                //Clear Out Arrays
                ctrl.selectedFilters.filters.MakeModel = [];
                ctrl.selectedFilters.filters.Trims = [];
                ctrl.filterOptions.Trims = [];
                ctrl.filterOptions.MakeModel.unshift({ Make: filterValue, Model: "All Models" });
                ctrl.filterOptions.Trims.unshift({ Make: filterValue, Model: "All Models", Trim: "All Trims" });
                $scope.selectModel = ctrl.filterOptions.MakeModel[0];
                ctrl.currentModel = $scope.selectModel.Model;
                $scope.selectTrim = ctrl.filterOptions.Trims[0];
               
                //Update Results
                updateQueryString(filterName);
                DoSearch();
            };

            ctrl.toggleModelItem = function (makeName, modelName, oldModelName) {

                var makeModel = {
                    Make: makeName,
                    Model: modelName
                };

                updateTrimQueryString(ctrl.currentMake, modelName, '');

                // Reset Array
                ctrl.filterOptions.Trims = [];
                if (ctrl.modelName !== 'All Models') {
                    InventoryFilterService.GetTrims(makeName, modelName, ctrl.selectedFilters.filters.Condition === 'New')
                        .then(function (data) {
                            if (data.data) {
                                data = data.data;
                            }
                            angular.forEach(data,
                                function (trim) {
                                    var makeModelTrim = {
                                        Make: makeName,
                                        Model: modelName,
                                        Trim: trim
                                    };
                                    ctrl.filterOptions.Trims.push(makeModelTrim);
                                });

                        }).finally(function () {});
                }
                        

                //Clear Arrays
                ctrl.selectedFilters.filters.MakeModel = [];
                ctrl.selectedFilters.filters.Trims = [];

                if (makeModel.Model === "All Models") {
                    makeModel.Make = ctrl.currentMake;
                } else {
                    ctrl.selectedFilters.filters.MakeModel.push(makeModel);
                }
                ctrl.filterOptions.Trims.unshift({ Make: makeName, Model: modelName, Trim: "All Trims" });
                $scope.selectTrim = ctrl.filterOptions.Trims[0];
                ctrl.currentModel = modelName;
                updateMakeModelQueryString(ctrl.currentMake, modelName);
                DoSearch();

            };

            ctrl.toggleModelSelected = function (make, model) {
                var i = ctrl.selectedFilters.filters.MakeModel.length;
                while (i--) {
                    if (ctrl.selectedFilters.filters.MakeModel[i].Make === make &&
                        ctrl.selectedFilters.filters.MakeModel[i].Model === model) {
                        return true;
                    }
                }
                return false;
            }

            ctrl.toggleTrimSelected = function (make, model, trim) {
                var i = ctrl.selectedFilters.filters.Trims.length;
                while (i--) {
                    if (ctrl.selectedFilters.filters.Trims[i].Make === make &&
                        ctrl.selectedFilters.filters.Trims[i].Model === model &&
                        ctrl.selectedFilters.filters.Trims[i].Trim === trim) {
                        return true;
                    }
                }
                return false;
            }

            ctrl.toggleFilterItem = function (filterName, filterValue) {
                if (typeof ctrl.selectedFilters.filters[filterName] === 'string' || typeof ctrl.selectedFilters.filters[filterName] === "boolean") {
                    ctrl.selectedFilters.filters[filterName] = filterValue;
                }
                else {
                    if (ctrl.selectedFilters.filters[filterName].indexOf(filterValue) > -1) {
                        var index = ctrl.selectedFilters.filters[filterName].indexOf(filterValue);
                        ctrl.selectedFilters.filters[filterName].splice(index, 1);
                    } else {
                        ctrl.selectedFilters.filters[filterName].push(filterValue);                    
                    }
                }

                updateQueryString(filterName);
                DoSearch();
            };

            // MPG Max/Min Value Change Event
            ctrl.toggleMpgFilterItem = function (filterName, event) {
                
                if (filterName.toLowerCase() == "mpgmin") {

                    var selectedVal = ($scope.selectMPGMin == null) ? "" : $scope.selectMPGMin.trim();
                    var mpgMin = (ctrl.selectedFilters.filters["MPGMin"] == null) ? "" : ctrl.selectedFilters.filters["MPGMin"];

                    // If current value & old value is same just leave it, no search will perform
                    if (selectedVal == mpgMin)
                        return false;
                    else {
                        ctrl.selectedFilters.filters[filterName] = (event.target.value.trim() == "") ? null : Number(event.target.value);
                        var minVal = isNaN(ctrl.selectedFilters.filters["MPGMin"]) ? 0 : Number(ctrl.selectedFilters.filters["MPGMin"]);
                        var maxVal = isNaN(ctrl.selectedFilters.filters["MPGMax"]) ? 0 : Number(ctrl.selectedFilters.filters["MPGMax"]);
                        // If min value is greater than max value, then keep the max value into min value field
                        if (minVal > maxVal && maxVal > 0) {
                            $scope.selectMPGMin = $scope.selectMPGMax;
                            ctrl.selectedFilters.filters["MPGMin"] = $scope.selectMPGMax;
                        }
                    }
                }

                if (filterName.toLowerCase() == "mpgmax") {

                    var selectedVal = ($scope.selectMPGMax == null) ? "" : $scope.selectMPGMax.trim();
                    var mpgMax = (ctrl.selectedFilters.filters["MPGMax"] == null) ? "" : ctrl.selectedFilters.filters["MPGMax"];

                    if (selectedVal == mpgMax)
                        return false;
                    else {
                        ctrl.selectedFilters.filters[filterName] = (event.target.value.trim() == "") ? null : Number(event.target.value);
                        var minVal = isNaN(ctrl.selectedFilters.filters["MPGMin"]) ? 0 : Number(ctrl.selectedFilters.filters["MPGMin"]);
                        var maxVal = isNaN(ctrl.selectedFilters.filters["MPGMax"]) ? 0 : Number(ctrl.selectedFilters.filters["MPGMax"]);
                        // If max value is less than min value, then keep the min value into max value field
                        if (minVal > maxVal && maxVal > 0) {
                            $scope.selectMPGMax = $scope.selectMPGMin;
                            ctrl.selectedFilters.filters["MPGMax"] = $scope.selectMPGMin;
                        }
                    }
                }
                updateQueryString(filterName);
                DoSearch();
            }

            ctrl.onlyNumbers = function (evt) {
                evt = (evt) ? evt : window.event;
                var charCode = (evt.which) ? evt.which : evt.keyCode;
                if (charCode > 31 && (charCode < 48 || charCode > 57)) {
                    event.preventDefault();
                }
            }

            var updateQueryString = function (fld) {
                if (typeof ctrl.selectedFilters.filters[fld] === 'boolean') {
                    if (ctrl.selectedFilters.filters[fld] === false)
                        $location.search(fld, null);
                    else
                        $location.search(fld, ctrl.selectedFilters.filters[fld].toString());
                } else if (ctrl.selectedFilters.filters[fld] !== '') {
                    if (fld === 'Makes') {
                        var makeFilter = (ctrl.currentMake !== 'All Makes') ? ctrl.currentMake : null;
                        $location.search(fld, makeFilter);
                    } else {
                        $location.search(fld, ctrl.selectedFilters.filters[fld]);
                    }
                } else {
                    $location.search(fld, null);
                }
            };

            var updateMakeModelQueryString = function (make, model) {
                var queryStr = (make && model && model !== 'All Models') ? make + '|' + model : null;
                $location.search('MakeModel', queryStr);
            };

            var updateTrimQueryString = function (make, model, trim) {
                var queryTrim = (trim !== '' && trim !== 'All Trims' ) ? make + '|' + model + '|' + trim : null;
                $location.search('Trims', queryTrim);
            };

            var DoSearch = function () {
                ctrl.ZipCode = ZipCodeService.Location.CurrentZipCode;
                ctrl.selectedFilters.filters.ZipCode = ctrl.ZipCode;
                updateQueryString('ZipCode');
                ctrl.isloading = true;
                InventorySearchService.RetrieveFeaturedVehicles();
                InventorySearchService.RetrieveVehicles().then(function () {
                    ctrl.openAutomatically();
                    $timeout(function () {
                        ctrl.isloading = false;
                    }, 1000);
                });
            }

            ctrl.fillSortBy = function (sortBy) {
                return (ctrl.selectedFilters.filters.SortBy === sortBy) ? 'black' : 'white';
            };

            $scope.toggleFilterListDisplay = function (obj, $event) {
                InventoryFilterService.ToggleFilterList(obj, $event).then(function () {
                    $scope.$broadcast('rzSliderForceRender');
                });
            };

            //Pick first item in comma separated list 
            ctrl.firstItem = function (str) {
                var string = str.toString().split(',');
                return string[0];
            }

            NotificationService.subscribe("saveZipCode", $scope, DoSearch);
        }],
        templateUrl: UrlContent('/App/SearchResult/Views/InventoryFiltersComponent.html?x')
    });
})(angular.module('AutoSMART.Web.Search'));
"use strict";

(function (module) {

    module.component('inventorylistcomponent', {
        bindings: {
            isloading: '='
        },

        controller: ["$scope", "$timeout", "$window", "$log", '$sce', "$location", "InventorySearchService", "InventoryFilterService",
            function ($scope, $timeout, $window, $log, $sce, $location, InventorySearchService, InventoryFilterService) {

                var ctrl = this;
                var $spotlightSlider = $("#spotlights");
                var numOfSlides = 0;
                var smallScreen = 781;
                var spotlightOptions = {
                    animation: "fade",
                    selector: ".slides > .slide",
                    slideshow: false,
                    touch: true,
                    //itemWidth: 320,
                    itemMargin: 20,
                    minItems: 0,
                    maxItems: 1
                }
                ctrl.pageSized = 15;
                ctrl.first = 1;
                ctrl.second = ctrl.pageSized;
                ctrl.selectedItem = '';

                $window.onresize = function (event) {
                    numOfSlides = (ctrl.allVehicles.Spotlights.length > 3) ? 3 : ctrl.allVehicles.Spotlights.length;
                    $spotlightSlider = $("#spotlight-cars");

                    ctrl.cardOrientation = 'vertical-card';
                    if ($window.innerWidth >= 1200) {
                        ctrl.cardOrientation = 'horizontal-card';
                    }

                    //Initialize the slider if window is small enough, else detroy the slider.
                    if ($window.innerWidth < smallScreen && numOfSlides > 1) {
                        if ($spotlightSlider.find('.flex-active-slide').length == 0) $spotlightSlider.flexslider(spotlightOptions);
                    } else {
                        if ($spotlightSlider.find('.flex-active-slide').length > 0) {
                            $spotlightSlider.flexslider('destroy');
                        }
                        $spotlightSlider.find('.slide').removeAttr('style');
                    }
                }
                //Initalize the flexSlider on page load, if small screen.
                $scope.initFlexSlider = function () {
                    numOfSlides = ctrl.allVehicles.Spotlights.length;
                    $spotlightSlider = $("#spotlight-cars");
                    if ($window.innerWidth < smallScreen && numOfSlides > 1) {
                        $timeout(function () {
                            $spotlightSlider.flexslider(spotlightOptions);
                        }, 100);
                    }
                }

                ctrl.$onInit = function () {

                    $(document).ready(function () {
                        $('[data-toggle="popover"]').popover({
                            placement: 'right',
                            trigger: 'hover'
                        });

                    });


                    ctrl.selectedFilters = InventoryFilterService.selectedFilters;
                    ctrl.filterOptions = InventoryFilterService.filterOptions;
                    ctrl.allVehicles = InventorySearchService.allVehicles;
                    ctrl.allVehicles.SearchResults.forEach(function (element) {
                        element.Make = '';
                        element.Model = '';
                    });

                    ctrl.cardOrientation = 'vertical-card';
                    if ($window.innerWidth >= 1200) {
                        ctrl.cardOrientation = 'horizontal-card';
                    }

                    //Get URL variables
                    var url = $location.search();
                    ctrl.selectedSort = ctrl.filterOptions.SortBy[0].Key;
                    ctrl.selectedItem = ctrl.filterOptions.SortBy[0];

                    if (url.SortBy) {
                        for (var i = 0; i < ctrl.filterOptions.SortBy.length; i++) {
                            if (ctrl.filterOptions.SortBy[i].SearchValue === url.SortBy) {
                                ctrl.selectedSort = ctrl.filterOptions.SortBy[i].Key;
                                ctrl.selectedItem = ctrl.filterOptions.SortBy[i];
                                break;
                            }
                        }
                    }

                    // Set Pagination Text Strings
                    ctrl.setPageValues(ctrl.getLocation('page'), ctrl.allVehicles.SearchTotalCount);

                }
                ctrl.toggleSortByDropdown = function () {
                    var val = ctrl.filterOptions.SortBy.find(el => el.Key.trim() === ctrl.selectedItem.Key.trim());
                    ctrl.selectedFilters.filters.SortBy = val.SearchValue;
                    var va = ctrl.filterOptions.SortBy.length;
                    $scope.$parent.$parent.updateQueryString('SortBy');
                    ctrl.isloading = true;
                    InventorySearchService.RetrieveFeaturedVehicles();
                    InventorySearchService.RetrieveVehicles().then(function () {
                        $timeout(function () {
                            ctrl.isloading = false;
                            ctrl.first = 1;
                            ctrl.second = (ctrl.allVehicles.SearchTotalCount < ctrl.pageSized) ? ctrl.allVehicles.SearchTotalCount : ctrl.pageSized;
                        }, 1000);
                    });
                };


                ctrl.toggleSortBy = function (sort) {
                    ctrl.selectedFilters.filters.SortBy = sort.SearchValue;
                    $scope.$parent.$parent.updateQueryString('SortBy');
                    ctrl.isloading = true;
                    InventorySearchService.RetrieveFeaturedVehicles();
                    InventorySearchService.RetrieveVehicles().then(function () {
                        $timeout(function () {
                            ctrl.isloading = false;
                            ctrl.first = 1;
                            ctrl.second = (ctrl.allVehicles.SearchTotalCount < ctrl.pageSized) ? ctrl.allVehicles.SearchTotalCount : ctrl.pageSized;
                        }, 1000);
                    });
                };

                $scope.toggleFilterListDisplay = function (obj, $event) {
                    InventoryFilterService.ToggleFilterList(obj, $event);
                    $scope.$broadcast('rzSliderForceRender');
                };
                //Capture pager button click
                ctrl.pagingAction = function (text, page, pageSize, total) {
                    //Scroll top, then load the next page
                    var scrolled = false;
                    $('html, body').animate({ scrollTop: 0 }, 400, function () {
                        ctrl.isloading = true;
                        if (!scrolled) {
                            scrolled = true;
                            InventorySearchService.RetrieveMoreVehicles(page).then(function () {
                                $timeout(function () {
                                    var el = document.getElementById('screenreader-text');
                                    el.focus();
                                    ctrl.isloading = false;
                                    //Update the results text
                                    ctrl.setPageValues(page, ctrl.allVehicles.SearchTotalCount);
                                }, 1000);
                            });
                        }
                    });
                };
                //Get current location for href values in pager 
                ctrl.getLocation = function (type) {
                    var url = $location.$$absUrl;
                    var href = (url.split('#page=')[0]) ? url.split('#page=')[0] : url;
                    var pageNumber = (url.split('#page=')[1]) ? url.split('#page=')[1] : 1; //Default to 1st page
                    return (type == 'href') ? href : pageNumber;
                };

                //Watch Hash Change (from browser back and forward) and trigger page change
                $scope.$on('$locationChangeSuccess', function (event, newUrl, oldUrl) {
                    var newPage = ctrl.getLocation('page');
                    ctrl.pagingAction('Hash Changed!', newPage, ctrl.pageSized, ctrl.allVehicles.SearchTotalCount);
                });

                // Set the Page Text strings
                ctrl.setPageValues = function (page, total) {
                    ctrl.first = (page == 1) ? 1 : ((page - 1) * ctrl.pageSized) + 1;
                    ctrl.second = (total >= (ctrl.first + ctrl.pageSized)) ? ctrl.first + ctrl.pageSized - 1 : total;
                }

            }],

        templateUrl: UrlContent("/App/SearchResult/Views/InventoryListComponent.html?1"),


    });
})(angular.module('AutoSMART.Web.Search'));

"use strict";

(function (module) {

    module.component('searchresultcard', {

        controller: ["$scope", "$uibModal", "Config", "$rootScope", "CalculatorService", "GoogleAnalyticsService", "$window", "VehicleFavoriteService", "InventoryImageSizeService", "VehiclePricingService", "HidePriceDifferenceService", "DedicatedDealerHeaderService", "QuickQuoteService",
            function ($scope, $uibModal, Config, $rootScope, CalculatorService, GoogleAnalyticsService, $window, VehicleFavoriteService, InventoryImageSizeService, VehiclePricingService, HidePriceDifferenceService, DedicatedDealerHeaderService, QuickQuoteService) {
                var ctrl = this;
                // Dedicated Dealer Header Service only being used to get main dealer phone number from CEM
                ctrl.dedicatedDealerContent = DedicatedDealerHeaderService.DedicatedDealerContent;
                ctrl.loadingState = 0;
                $scope.displayDealerRating = ctrl.data.Rating && ctrl.data.Rating > 0 ? true : false;
                $scope.displayContactlessServiceTag = ctrl.data.HasHomeDeliverySales
                    || ctrl.data.HasHomeTestDrives
                    || ctrl.data.HasNoContactTransactions
                    || ctrl.data.HasVirtualAppointments;

                $scope.displayAsxCard = ctrl.data.IsAutoSmartXLive ? true : false;
                ctrl.data.IsPreferredPlus = $scope.displayAsxCard;
                ctrl.data.DealerName = ctrl.data.DealerName;
                $scope.ClientLogo = Config.ClientLogo;
                $scope.displayOdometer = ctrl.data.PhysicalCondition.toLowerCase() == 'used' ? true : false;
                ctrl.VDPImageSize = InventoryImageSizeService.images.SRPVehicle;
                ctrl.data.CalcContent = CalculatorService.CalcContent;
                ctrl.data.PreQualFormData = QuickQuoteService.GetPreQualFormData();
                ctrl.isNoQQ = !CalculatorService.qqSelectedRateTermCookie;                   
                if (ctrl.tabindexseq) {
                    $scope.tabindexseqstart = ctrl.tabindexseq;
                } else {
                    $scope.tabindexseqstart = 52;
                }

                ctrl.data.ListPrice = (ctrl.data.ListPrice && ctrl.data.ListPrice !== 0) ? ctrl.data.ListPrice : null;
                ctrl.VDPLink = function (itemId) {
                    return '/Vehicle/Details/' + itemId + '?itemViewSource=SRP';
                }
                ctrl.svgcontent = {
                    "TextColor": "#FFF",
                    "ShieldColor": "#FFF"
                };
                ctrl.ClientColorlessLogoUrl = Config.ClientColorlessLogoUrl;

                ctrl.stockPhotoMessage = 'This image is a stock photo and is not an exact representation of any vehicle offered for sale. Advertised vehicles of this model may have styling, trim levels, colors and optional equipment that differ from the stock photo.';
                ctrl.data.pageType = 'SRP';
            
                //If CU doesn't enable overprice guidance, don't get pricing data for vehicle
                if (ctrl.data.MarketPrice && (ctrl.data.PriceRetail && ctrl.data.PriceRetail !== 0)
                    && (Config.EnablePriceGuidance === 'true' || ctrl.data.DealTypeId !== 3)) {
                    ctrl.data.PricingData = VehiclePricingService.GetPricingData(ctrl.data.PriceRetail, ctrl.data.MarketPrice, ctrl.data.DealTypeId);
                }

                $scope.openLocation = function () {
                    var modalInstance = $uibModal.open({
                        component: 'locationcomponent',
                        scope: $scope
                    });

                    $rootScope.modalInstance = modalInstance;

                    modalInstance.result.then(function (data) {
                        if (data.data) {
                            data = data.data;
                        }
                    });
                };

                ctrl.openRating = function (isValid) {
                    if (isValid) {
                        var ratingInstance = $uibModal.open({
                            component: 'dealerratercomponent',
                            scope: $scope,
                            windowClass: 'dealerrater-modal-content'
                        });

                        $scope.ratingInstance = ratingInstance;
                    }
                };

                ctrl.open = function () {
                    var interstitial = $uibModal.open({
                        animation: true,
                        ariaDescribedBy: 'interstitial-modal-body',
                        templateUrl: '/app/Common/views/_InterstitialModal.html',
                        component: 'interstitialmodal',
                        scope: $scope,
                        windowClass: 'interstitial-modal-content'
                    });
                    $scope.Interstitial = interstitial;
                };

                ctrl.openPriceAnalysisModal = function () {
                    ctrl.PriceComparisonClick = GoogleAnalyticsService.PriceComparisonClick;
                    ctrl.PriceComparisonClick();
                    var modalInstance = $uibModal.open({
                        component: "priceanalysismodalcomponent",
                        scope: $scope,
                        windowClass: 'vdplead-modal-content'
                    });
                    $scope.modalLeadInstance = modalInstance;
                };

                ctrl.hidePriceDifference = function (location) {
                    var result = HidePriceDifferenceService.IsDealerFromTexas(location);
                    return result;
                };

                ctrl.setSource = function (sourcefrom){
                    sessionStorage.setItem("srpSource", sourcefrom);
                };

                ctrl.imageError = function (event) {
                    console.log(event)
                    
                    var images = JSON.parse(Config.ImageSizes.replace(/&quot;/g, '"'));
                    var selectedImageSize;
                    angular.forEach(images, function (obj) {
                        if (obj.ImageSizeId == ctrl.VDPImageSize) {
                            selectedImageSize = obj;
                            return;
                        }

                    });

                    // no image is given, use the no photo
                    var noImagePath = selectedImageSize.NoImagePath;
                    event.target.src = Config.ImageServerWebsitePath + noImagePath;
                };
            }
        ],
        bindings: {
            data: '=',
            tabindexseq: '=',
            sourcefrom: '@'
        },
        templateUrl: UrlContent("/App/SearchResult/Views/searchResult_card.html?")


    });
})(angular.module('AutoSMART.Web.Search'));

"use strict";

(function (module) {

    module.component('spotlightcard', {

        controller: ["$location", "GoogleAnalyticsService", "Config","InventoryImageSizeService",
    function ($location, GoogleAnalyticsService, Config, InventoryImageSizeService) {
             var ctrl = this;

             ctrl.VDPLink = function (itemId) {
                 return '/Vehicle/Details/' + itemId + '/?itemViewSource=SRP';
             }
             ctrl.SpotlightGA = function (itemId) {
                 GoogleAnalyticsService.SpotlightClick(itemId);
             }

             ctrl.SRPSpotlightImage = InventoryImageSizeService.images.SRPSpotlightImage;
             ctrl.SRPSpotlightCompareImage = InventoryImageSizeService.images.Compare;
             ctrl.dealerLogoUrl = getDealerLogoPath();
             ctrl.HasPrice = (ctrl.vehicle.PriceRetail && ctrl.vehicle.PriceRetail > 0);
        
             function getDealerLogoPath () {
                 if (!ctrl.vehicle.DealerLogoUpdateDate) return null;
                 
                 var logoDate = Date.parse(ctrl.vehicle.DealerLogoUpdateDate);
                 var time = 0;
                 if (isNaN(logoDate) == false) {
                     time = new Date(logoDate).getTime();
                 }
                 var epochTicks = 621355968000000000;
                 var ticksPerMillisecond = 10000;
                 var ticks = epochTicks + (time * ticksPerMillisecond);
                 var dealerImage = "/Content/DealerLogo/" + ctrl.vehicle.DealerId + "/?" + ticks;
                 return (!dealerImage || 0 === dealerImage.length) ? Config.ImageServerWebsitePath + "no_logo_(168x104).jpg" : dealerImage;
             }

         }],

        bindings: {
            vehicle: '='
        },
        templateUrl: "/App/SearchResult/Views/searchResult_spotlightCard.html?2223243wwq"


    });
})(angular.module('AutoSMART.Web.Search'));

"use strict";

(function (module) {

    module.component('dedicateddealerheadercomponent',
    { 
        templateUrl: UrlContent("/App/SearchResult/Views/DedicatedDealerHeaderComponent.html"),
        bindings: {
            data: "="
        },
        controller: ["$scope", "$uibModal", "$rootScope", "DedicatedDealerHeaderService", "InventoryFilterService", function ($scope, $uibModal, $rootScope, DedicatedDealerHeaderService, InventoryFilterService) {
            var ctrl = this;

            ctrl.$onInit = function () {
                ctrl.dedicatedDealerContent = DedicatedDealerHeaderService.DedicatedDealerContent;
                ctrl.isConditionNew = InventoryFilterService.selectedFilters.filters.Condition === "New" ? true : false;
            };
            ctrl.svgcontent = {
                "TextColor": "white",
                "ShieldColor": "white"
            };
            ctrl.openRating = function () {
                var ratingInstance = $uibModal.open({
                    component: 'dealerratercomponent',
                    scope: $scope,
                    windowClass: 'dealerrater-modal-content'
                });

                $scope.ratingInstance = ratingInstance;
            };
            
            $scope.openLocation = function () {

                var modalInstance = $uibModal.open({
                    component: 'locationcomponent',
                    windowClass: 'location-modal-content',
                    scope: $scope
                });

                $rootScope.modalInstance = modalInstance;

                modalInstance.result.then(function (data) {
                    if (data.data) {
                        data = data.data;
                    }
                });
            };

        }]
       
    });
})(angular.module('AutoSMART.Web.Search'));