<?php

namespace App\Http\Controllers\Frontend;

use App\Http\Controllers\Controller;
use App\Libs\Facades\Localization;
use App\Libs\Support\Mailchimp;
use App\Libs\Support\Sanitizer\Sanitizer;
use App\Mail\AssessmentReceived;
use App\Mail\ContactMail;
use Assessment;
use BlogPost;
use CaseStudy;
use Contact;
use Country;
use EventItem;
use Illuminate\Support\Facades\Mail;
use Illuminate\Support\Facades\Storage;
use Illuminate\Support\Facades\Validator;
use News;
use NewsletterSubscription;
use Office;
use PressRelease;
use Project;
use Publication;
use ReCaptcha\ReCaptcha;
use Sector;
use Solution;
use Visitor;
use VisitorDownload;
use VisitorToken;
use App\Http\Resources\Project as ProjectResource;
use Clipping;

class AjaxController extends Controller
{
    public function postBlogPosts()
    {
        $validator = Validator::make(
            request()->all(),
            array(
                'page' => 'required|integer|min:1',
                'rows' => 'required|integer|between:1,20',
                'categories' => 'array',
                'search' => 'string|max:100'
            )
        );

        if ($validator->fails()) {
            return response()->json(array(
                "error" => "validation",
                "description" => "bad syntax",
                "validation" => $validator->messages()
            ), 400);
        }
        $rows = request()->input('rows');
        $page = request()->input('page');
        $cats = request()->input('categories');

        $sanitizer = new Sanitizer(['search' => request()->input('search')], ['search' => 'strip_tags|xss_clean|trim']);
        $sanitizedData = $sanitizer->sanitize();
        $searchString = $sanitizedData['search'];

        // $featuredPostQuery = BlogPost::full()
        //     ->with(['media', 'authors'])
        //     ->where('status', 'published')
        //     ->where('lang_status', 'published')
        //     ->where('is_feature_post', '1')
        //     ->inCategories($cats)
        //     ->search($searchString);

        // $featuredPost = $featuredPostQuery->orderBy('date', 'desc')
        //     ->first();

        // if ($page == 1 && $featuredPost) {
        //     $rows = $rows - 2;
        // }

        $postsQuery = BlogPost::full()
            ->with(['media', 'authors'])
            ->where('status', 'published')
            ->where('lang_status', 'published')
            // ->where('blog_posts.id', '!=', $featuredPost ? $featuredPost->id : 0)
            ->inCategories($cats)
            ->search($searchString);

        if (!$searchString) {
            $postsQuery->orderBy('date', 'desc');
        }

        // $offset = $page === 1 ? 0 : ($page - 1) * $rows - ($featuredPost ? 2 : 0);
        $offset = $page === 1 ? 0 : ($page - 1) * $rows;

        $count = $postsQuery->count();

        $posts = $postsQuery->offset($offset)
            ->limit($rows)
            ->get();

        return view('frontend/templates/components/blog_list', array(
            'posts' => $posts,
            'page' => $page,
            'total' => $count,
        ));
    }

    public function postCaseStudies()
    {

        $validator = Validator::make(
            request()->all(),
            array(
                'page' => 'required|integer|min:1',
                'rows' => 'required|integer|between:1,50',
                'type' => 'in:corporate,public',
                'sector' => 'integer'
            )
        );

        if ($validator->fails()) {
            return response()->json(array(
                "error" => "validation",
                "description" => "bad syntax",
                "validation" => $validator->messages()
            ), 400);
        }

        $query = CaseStudy::full()->with(array(
            "overviewImage",
            "sectors" => function ($query) {
                $query->full()->select("id", "title", "sector_type");
            },
            "downloads" => function ($query) {
                $query->full()->orderBy("case_study_publication.position", "asc")
                    ->select("id")
                    ->with(array(
                        "document" => function ($query) {
                            $query->wherePivot("language_id", Localization::getActiveLocale());
                        }
                    ));
            }
        ))
            ->select("id", "title", "tagline", "overview_image_id", "summary", "lang_uri as uri", "lang_slug as slug")
            ->where("status", "published")
            ->where("lang_status", "published")
            ->orderBy("position");

        $sectorId = request()->input("sector");
        $sectorType = request()->input("type");

        if (!empty($sectorId) && $sectorId) {
            $query->whereHas("sectors", function ($q) use ($sectorId) {
                $q->where("id", "=", $sectorId);
            });
        } elseif (!empty($sectorType)) {
            $query->whereHas("sectors", function ($q) use ($sectorType) {
                $q->where("sector_type", "=", $sectorType);
            });
        }

        $caseStudies = $query->get();
        $sector = null;
        if (!empty($sectorId)) {
            $sector = Sector::full()->where("id", $sectorId)
                ->select("id", "title", "tagline", "lang_uri", "lang_slug")
                ->first();
        }

        return view('frontend/templates/components/case_studies_list',
            array("caseStudies" => $caseStudies, "sector" => $sector));
    }

    public function postProjects()
    {
        $validator = Validator::make(
            request()->all(),
            array(
                'page' => 'required|integer|min:1',
                'rows' => 'required|integer|between:1,200',
                'search' => 'alpha_num_space',
                // 'mapBounds' => 'regex:/^-?[0-9]\d*(\.\d+)?,-?[0-9]\d*(\.\d+)?,-?[0-9]\d*(\.\d+)?,-?[0-9]\d*(\.\d+)?$/',
                'topic' => 'array',
                'topic.*' => 'integer',
                'cobenefit' => 'array',
                'cobenefit.*' => 'integer',
                'technology' => 'array',
                'technology.*' => 'integer',
                'standard' => 'array',
                'standard.*' => 'integer',
                'location' => 'array',
                'location.*' => 'in:africa,asia,europe,north_america,south_america,oceania',
                'country' => 'array',
                'country.*' => 'integer',
                'cf_type' => 'array',
                'cf_type.*' => 'in:au,carbon,gold',
                'isMobile' => 'boolean',
            )
        );

        if ($validator->fails()) {
            return response()->json(array(
                "error" => "validation",
                "description" => "bad syntax",
                "validation" => $validator->messages()
            ), 400);
        }
        //Log::info('AJAX projects - Validation successful');
        $topics = request()->input("topic");
        $cobenefits = request()->input("cobenefit");
        $technologies = request()->input("technology");
        $countries = request()->input("country");
        $standards = request()->input("standard");
        $locations = request()->input("location");
        $page = request()->input("page");
        $rows = request()->input("rows");
        // $mapBounds = request()->input("mapBounds");
        $searchString = request()->input("search");
        $isMobile = request()->input("isMobile");

        $query = Project::full()->with(array(
            "overviewImage",
            /*
            "technologies" => function ($query) {
                $query->full()->select("id", "lang_slug as slug", "lang_uri as uri", "title", "icon_light_id",
                    "icon_id", "icon_cf_id")
                    ->with("iconLight", "icon", "iconCf")
                    ->orderBy('project_technologies.position');
            },
            "standards" => function ($query) {
                $query->full()
                    ->select("id", "lang_slug as slug", "lang_uri as uri", "title", "logo_image_id")
                    ->with('logoImage')
                    ->orderBy('project_standards.position');
            },
            */
            "country" => function ($query) {
                $query->full()->select("id", "title");
            },
            /*
            "cobenefits" => function ($query) {
                $query->full()->select("id", "project_id", "cobenefit_id")
                    ->orderBy("website_objects.position")
                    ->with(array(
                        "cobenefit" => function ($query) {
                            $query->full()
                                ->select("id", "lang_uri as uri", "title", "lang_slug as slug", "icon_dark_id",
                                    "icon_cf_id")
                                ->with("iconDark", "iconCf");
                        }
                    ));
            }
            */
        ))->select("id", "projects_lang.title", "lang_uri as uri", "lang_slug as slug", "location_lat",
            "location_lng",
            "website_objects.website_object_id", "overview_image_id",
            "projects.country_id")
        ->where("status", "published")
        ->where("lang_status", "published")
        ->where("is_hero", true);

        $query->orderBy('position');

        //Log::info('AJAX projects - Begin Model filters');
        if (!empty($topics)) {
            $query->filterByTopics($topics);
        }

        if (!empty($cobenefits)) {
            $query->filterByCobenefits($cobenefits);
        }

        if (!empty($technologies)) {
            $query->filterByTechnologies($technologies);
        }

        if (!empty($standards)) {
            $query->filterByStandards($standards);
        }

        if (!empty($locations)) {
            $query->filterByLocations($locations);
        }

        if (!empty($countries)) {
            $query->filterByCountries($countries);
        }

        if (!empty($mapBounds)) {
            $bounds = explode(",", $mapBounds);
            $query->filterByBounds($bounds);
        }

        if ($searchString) {
            $query->where(function ($query) use ($searchString) {
                $query->orWhere('projects_lang.title', 'like', '%'.$searchString.'%')
                    ->orWhere('projects_lang.content', 'like', '%'.$searchString.'%');
            });
        }

        if ($page > 1) {
            $query->skip(($page - 1) * $rows);
        }

        $projects = $query->take($rows)->get();
        $projectPages = [];
        $projectPage = '';
        $projectOne = null;
        $projectsPerPage = 8;
        $invert = false;
        $colorId = 0;
        $colorArray = ['green', 'yellow', 'blue', 'orange'];
        foreach($projects as $i => $project) {
            if ($isMobile) {
                $projectPage .= view(
                    'frontend.templates.blocks.project-slide-mobile',
                    [
                        'project' => $project,
                        'container_class' => 'project-slide-mobile--single',
                        'box_color' => 'project-slide-mobile--'.$colorArray[$colorId],
                    ]
                )->render();
                $colorId = $colorId >= 3 ? 0 : $colorId + 1;
            } else {
                if ($i % 2 === 1) {
                    $invert = ($i / 2) % 2 === 0;
                    $projectPage .= view(
                        'frontend.templates.blocks.project-slide',
                        [
                            'projectOne' => $projectOne,
                            'projectTwo' => $project,
                            'invert' => $invert,
                            'container_class' => 'project-slide--single',
                            'box_color' => 'project-slide--'.$colorArray[$colorId],
                        ]
                    )->render();
                    $projectOne = null;
                    $colorId = $colorId >= 3 ? 0 : $colorId + 1;
                } else {
                    $projectOne = $project;
                }
            }
            if (($i + 1) % $projectsPerPage === 0) {
                $projectPages[] = $projectPage;
                $projectPage = '';
            }
        }
        if (!$isMobile && $projectOne !== null) {
            $projectPage .= view(
                'frontend.templates.blocks.project-slide',
                [
                    'projectOne' => $projectOne,
                    'invert' => !$invert,
                    'container_class' => 'project-slide--single'
                ]
            )->render();
        }
        if ($projectPage) {
            $projectPages[] = $projectPage;
        }

        $projects->loadRelated('sustainabilityTopics', 'position');

        return response()->json([
            'projects' => ProjectResource::collection($projects),
            'projectPages' => $projectPages
        ]);
        /*
        return view('frontend/templates/components/projects_map_list',
            array("projects" => $projects));
        */
    }

    public function postSolutions()
    {
        $validator = Validator::make(
            request()->all(),
            array(
                'page' => 'required|integer|min:1',
                'rows' => 'required|integer|between:1,50',
                'topic' => 'array',
                'topic.*' => 'integer',
                'value' => 'array',
                'sector' => 'array',
                'sector.*' => 'integer',
                'business_line' => 'array',
                'business_line.*' => 'integer',
            )
        );

        if ($validator->fails()) {
            return response()->json(array(
                "error" => "validation",
                "description" => "bad syntax",
                "validation" => $validator->messages()
            ), 400);
        }

        $topics = request()->input("topic");
        $values = request()->input("value");
        $sectors = request()->input("sector");
        $businessLines = request()->input("business_line");

        $query = Solution::full()->with(array(
            "overviewImage",
            "sustainability_topics" => function ($query) {
                $query->full()->select("id", "title", "color_scheme", "image_id")
                    ->orderBy("website_objects.position")
                    ->with("image");
            },
            "values" => function ($query) {
                $query->full()->select("id", "title")
                    ->orderBy("website_objects.position");
            },
            "businessLines" => function ($query) {
                $query->full()->select("id", "title")
                    ->orderBy("website_objects.position");
            },
        ))
            ->select("id", "title", "tagline", "lang_uri as uri", "lang_slug as slug",
                "website_objects.website_object_id", "overview_image_id", "fact_sheet_id")
            ->where("status", "published")
            ->where("lang_status", "published")
            ->orderBy("website_objects.position", 'asc');

        if (!empty($topics)) {
            $query->filterByTopics($topics);
        }

        if (!empty($values)) {
            $query->filterByValues($values);
        }

        if (!empty($sectors)) {
            $query->filterBySectors($sectors);
        }

        if (!empty($businessLines)) {
            $query->filterByBusinessLines($businessLines);
        }

        $solutions = $query->get();
        /*
        $projects->loadRelated('sustainabilityTopics', 'position',
            array("SustainabilityTopic" => array("image")));
        */
        return view('frontend/templates/components/solutions_list',
            array("solutions" => $solutions));
    }

    public function postOffices()
    {
        $validator = Validator::make(
            request()->all(),
            array(
                'viewType' => "in:list,home",
                'continent' => 'in:europe,asia,africa,oceania,north_america,south_america',
                'officeType' => 'in:offices,headquarters'
            )
        );

        if ($validator->fails()) {
            return response()->json(array(
                "error" => "validation",
                "description" => "bad syntax",
                "validation" => $validator->messages()
            ), 400);
        }

        $continent = request()->input("continent");
        $viewType = request()->input("viewType", 'list');
        $officeType = request()->input("officeType");

        $query = Office::full()->with(array(
            "country", "overviewImage", 'contact' => function ($q) {
                $q->with('image');
            }
        ))->where("status", "published")
            ->where("lang_status", "published")
            ->orderBy("website_objects.position", "asc");

        if ($continent) {
            $query->filterByContinent($continent);
        }

        if ($officeType && $officeType == 'headquarters') {
            $query->where('is_headquarter', 1);
        }

        $offices = $query->get();
        $officeMarkers = array();
        foreach ($offices as $office) {
            $image = $office->overviewImage ? getMediaUrl($office->overviewImage->filename, '420x670') : '';
            $contact = null;
            if ($office->contact) {
                $contactImage = null;
                $contactEmailLink = null;
                if ($office->contact->image) {
                    $contactImage = getMediaUrl($office->contact->image->filename, '200x200');
                }
                if ($office->contact->email) {
                    $contactEmailLink = email_link_tag($office->contact->email);
                }
                $contact = array(
                    'name' => $office->contact->name,
                    'image' => $contactImage,
                    'emailLink' => $contactEmailLink
                );
            }

            $marker = array(
                'markerType' => 'office',
                'id' => $office->id,
                'title' => $office->title,
                'location_lat' => $office->location_lat,
                'location_lng' => $office->location_lng,
                'location_zoom' => $office->location_zoom,
                'country' => $office->country->title,
                'continent' => $office->country->continent,
                'is_headquarter' => $office->is_headquarter,
                'content' => $office->content,
                'detailImage' => $image,
                'contact' => $contact
            );
            $officeMarkers[] = $marker;
        }

        if ($viewType == 'list') {
            $viewName = 'frontend/templates/components/offices_list';
            if (Localization::getWebsite()->id == 2) {
                $viewName = 'frontend/cf/templates/components/offices_list';
            }
            return response()->json([
                'offices' => view($viewName, [
                    'offices' => $offices,
                ])->render(),
                'officeMarkers' => $officeMarkers,
            ]);
        } elseif ($viewType == 'home') {
            return response()->json($officeMarkers);
        }
    }

    public function postEvents()
    {
        $today = date("Y-m-d");
        $validator = Validator::make(
            request()->all(),
            array(
                'month' => 'integer|between:1,12',
                'year' => 'integer|between:2010,2100',
                'highlightedSlug' => '',
                'page' => 'integer|min:1',
                'rows' => 'integer|between:1,50',
                'blockOnly' => 'boolean',
                'archive' => 'boolean'
            )
        );

        $blockOnly = request()->input('blockOnly');
        $page = request()->input('page', 1);
        $rows = request()->input('rows', 12);

        if ($validator->fails()) {
            return response()->json(array(
                "error" => "validation",
                "description" => "bad syntax",
                "validation" => $validator->messages()
            ), 400);
        }

        $month = request()->input("month");
        $year = request()->input("year");
        $archive = request()->input("archive");

        $query = EventItem::full()
            ->with(array(
                'media', 'document'
                => function ($query) {
                        $activeLang = Localization::getActiveLocale();
                        $query->where('event_items_documents.language_id', '=', $activeLang);
                    }
            ))
            ->where("status", "published")
            ->where("lang_status", "published")
            ->where("no_index", false);

        if ($archive != "true") {
            $query
                ->orderBy("date", "asc")
                ->whereRaw("end_date >= '{$today}'");
        } else {
            $query->orderBy("date", "desc")
                ->whereRaw("end_date < '{$today}'");
        }

        $query->orderBy("date", "desc");

        if ($month) {
            $query->whereRaw("MONTH(date) = {$month}");
        }

        if ($year) {
            $query->whereRaw("YEAR(date) = {$year}");
        }

        /*
        if ($month && $month > 0) {
            $year = date("Y");
            if ($month < date("m")) {
                $year += 1;
            }
            if ($month < 10) {
                $month = "0".$month;
            } // needed for between to work properly
            $query = $query->whereRaw(
                "'{$year}-{$month}' BETWEEN DATE_FORMAT(date,'%Y-%m') AND DATE_FORMAT(end_date,'%Y-%m') "
            );
        }
        */

        if ($page > 1) {
            $query->skip(($page - 1) * $rows);
        }

        $events = $query->take($rows)->get();
        $isEnd = $events->count() < $rows;

        if(isset($blockOnly) && $blockOnly) {
            return view(
                'frontend/templates/components/articles_list_items_v2',
                array("items" => $events, "type" => "event")
            );
        }

        return view('frontend/templates/components/articles_grid_items',
            array("items" => $events, "type" => "event", "isEnd" => $isEnd));
    }

    public function postNews()
    {
        $isCf = Localization::getWebsite()->id == 2;
        $validator = Validator::make(
            request()->all(),
            array(
                'year' => '',
                'type' => 'in:in_media,news,all,blog,press_release',
                'page' => 'integer|min:1',
                'rows' => 'integer|between:1,50',
                'blockOnly' => 'boolean',
            )
        );

        $blockOnly = request()->input('blockOnly');
        $page = request()->input('page', 1);
        $rows = request()->input('rows', 12);

        if ($validator->fails()) {
            return response()->json(array(
                "error" => "validation",
                "description" => "bad syntax",
                "validation" => $validator->messages()
            ), 400);
        }

        $year = request()->input("year");
        $type = request()->input("type");

        $query = News::full()
            ->with(array(
                'media', 'document'
                => function ($query) {
                        $activeLang = Localization::getActiveLocale();
                        $query->where('news_documents.language_id', '=', $activeLang);
                    }
            ))
            ->where("status", "published")
            ->where("lang_status", "published")
            ->orderBy("date", "desc");

        if ($year && $year != 'all') {
            $query = $query->whereRaw("Year(date) =".$year);
        }
        if ($type && $type != 'all') {
            $query = $query->where("type", $type);
        } else {
            $query = $query->whereIn("type", array('news', 'in_media', 'press_release'));
        }

        if ($page > 1) {
            $query->skip(($page - 1) * $rows);
        }

        $news = $query->take($rows)->get();
        $isEnd = $news->count() < $rows;

        if(isset($blockOnly) && $blockOnly) {
            return view(
                'frontend/templates/components/articles_list_items_v2',
                array("items" => $news, "type" => "news")
            );
        }

        return view(
            'frontend/templates/components/articles_grid_items',
            array("items" => $news, "type" => "news", "isEnd" => $isEnd)
        );
    }

    public function postClippings()
    {
        $validator = Validator::make(
            request()->all(),
            array(
                'page' => 'integer|min:1',
                'rows' => 'integer|between:1,50',
            )
        );

        $page = request()->input('page', 1);
        $rows = request()->input('rows', 12);

        if ($validator->fails()) {
            return response()->json(array(
                "error" => "validation",
                "description" => "bad syntax",
                "validation" => $validator->messages()
            ), 400);
        }

        $query = Clipping::full()
            ->where("status", "published")
            ->where("lang_status", "published")
            ->orderBy("date", "desc");

        if ($page > 1) {
            $query->skip(($page - 1) * $rows);
        }

        $clippings = $query->take($rows)->get();

        return view(
            'frontend/templates/components/clippings-list',
            array("articles" => $clippings)
        );
    }

    public function postPublications()
    {
        $validator = Validator::make(
            request()->all(),
            array(
                'year' => '',
                'type' => 'in:white_paper,fact_sheet,other,all,quick_guide,report',
                'page' => 'integer|min:1',
                'rows' => 'integer|between:1,50',
                'blockOnly' => 'boolean',
            )
        );

        $blockOnly = request()->input('blockOnly');
        $page = request()->input('page', 1);
        $rows = request()->input('rows', 12);

        if ($validator->fails()) {
            return response()->json(array(
                "error" => "validation",
                "description" => "bad syntax",
                "validation" => $validator->messages()
            ), 400);
        }

        $year = request()->input("year");
        $type = request()->input("type");

        $query = Publication::full()
            ->with('media')
            ->where("status", "published")
            ->where("lang_status", "published")
            ->where("list_on_publications", 1)
            ->orderBy("date", "desc");

        if ($year && $year != 'all') {
            $query = $query->whereRaw("Year(date) =".$year);
        }
        if ($type && $type != 'all') {
            $query = $query->where("type", $type);
        }

        if ($page > 1) {
            $query->skip(($page - 1) * $rows);
        }

        $publications = $query->take($rows)->get();
        $isEnd = $publications->count() < $rows;

        foreach ($publications as $publication) {
            $publication->content = $publication->details;
            $publication->isPublication = true;
        }

        if(isset($blockOnly) && $blockOnly) {
            return view(
                'frontend/templates/components/articles_list_items_v2',
                array("items" => $publications, "type" => "publication")
            );
        }

        return view('frontend/templates/components/articles_grid_items',
            array("items" => $publications, "type" => "publication", "isEnd" => $isEnd));
    }

    public function postReleases()
    {
        $website = Localization::getWebsite();

        $validator = Validator::make(
            request()->all(),
            array(
                'year' => '',
                'page' => 'integer|min:1',
                'rows' => 'integer|between:1,50'
            )
        );

        $page = request()->input('page', 1);
        $rows = request()->input('rows', 10);

        if ($validator->fails()) {
            return response()->json(array(
                "error" => "validation",
                "description" => "bad syntax",
                "validation" => $validator->messages()
            ), 400);
        }

        $year = request()->input("year");

        $query = PressRelease::full()
            ->with(array(
                'media', 'document'
                => function ($query) {
                        $activeLang = Localization::getActiveLocale();
                        $query->where('press_releases_documents.language_id', '=', $activeLang);
                    }
            ))
            ->where("status", "published")
            ->where("lang_status", "published")
            ->orderBy("date", "desc");

        if ($year && $year != 'all') {
            $query = $query->whereRaw("Year(date) =".$year);
        }

        if ($page > 1) {
            $query->skip(($page - 1) * $rows);
        }

        $releases = $query->take($rows)->get();

        return view('frontend/templates/components/articles_list_items',
            array("items" => $releases));
    }

    public function postFullSearch()
    {
        $validator = Validator::make(
            request()->all(),
            array(
                'page' => 'required|integer|min:1',
                'rows' => 'required|integer|between:1,50',
                'group' => 'in:resources,news,clients,solutions,projects'
            )
        );
        if ($validator->fails()) {
            return response()->json(array(
                "error" => "validation",
                "description" => "bad syntax",
                "validation" => $validator->messages()
            ), 400);
        }
        $website = Localization::getWebsite();

        $sanitizer = new Sanitizer(['search_string' => request()->input('search_string')],
            ['search_string' => 'strip_tags|xss_clean|trim']);
        $sanitizedData = $sanitizer->sanitize();
        $searchString = $sanitizedData['search_string'];

        $group = request()->input('group', false);

        $contentTypes = false;
        if ($group) {
            $contentTypes = $website->getSearchGroups($group);
        }

        $page = request()->input('page');
        $rows = request()->input('rows');
        $results = $website->search($searchString, false, $contentTypes, false, $rows, $page);

        $website = Localization::getWebsite();
        if ($website->id == 2) {
            return view('frontend/cf/templates/components/search_results',
                array("results" => $results['records']));
        } else {
            return view('frontend/templates/components/search_results',
                array("results" => $results['records']));
        }
    }

    public function postSearch()
    {
        $sanitizer = new Sanitizer(['search_string' => request()->input('search_string')],
            ['search_string' => 'strip_tags|xss_clean|trim']);
        $sanitizedData = $sanitizer->sanitize();
        $searchString = $sanitizedData['search_string'];

        if (strlen($searchString) < 3) {
            return response()->json(array());
        }

        $website = Localization::getWebsite();

        $resources = $website->search($searchString, false, array('page', 'publication', 'client'), false, 6);
        $news = $website->search($searchString, false, array('news', 'event_item', 'press_release', 'blog_post'), false,
            6);
        $clients = $website->search($searchString, false, array('case_study', 'sector'), false, 6);
        $solutions = $website->search($searchString, false, array('solution'), false, 6);
        $projects = $website->search($searchString, false, array('project'), false, 6);

        $results = array();

        if (!empty($resources)) {
            $results[] = array(
                'group' => 'resources',
                'groupLabel' => trans('frontend.resources'),
                'linkLabel' => trans('frontend.see_all').' '.trans('frontend.resources'),
                'items' => $resources
            );
        }
        if (!empty($news)) {
            $results[] = array(
                'group' => 'news',
                'groupLabel' => trans('frontend.news_and_events'),
                'linkLabel' => trans('frontend.see_all').' '.trans('frontend.news_and_events'),
                'items' => $news
            );
        }
        if (!empty($clients)) {
            $results[] = array(
                'group' => 'clients',
                'groupLabel' => trans('frontend.clients'),
                'linkLabel' => trans('frontend.see_all').' '.trans('frontend.clients'),
                'items' => $clients
            );
        }
        if (!empty($solutions)) {
            $results[] = array(
                'group' => 'solutions',
                'groupLabel' => trans('frontend.solutions'),
                'linkLabel' => trans('frontend.see_all').' '.trans('frontend.solutions'),
                'items' => $solutions
            );
        }
        if (!empty($projects)) {
            $results[] = array(
                'group' => 'projects',
                'groupLabel' => trans('frontend.projects'),
                'linkLabel' => trans('frontend.see_all').' '.trans('frontend.projects'),
                'items' => $projects
            );
        }

        return response()->json($results);
    }

    public function postSearchCf()
    {
        $sanitizer = new Sanitizer(['search_string' => request()->input('search_string')],
            ['search_string' => 'strip_tags|xss_clean|trim']);
        $sanitizedData = $sanitizer->sanitize();
        $searchString = $sanitizedData['search_string'];

        if (strlen($searchString) < 3) {
            return response()->json(array());
        }

        $website = Localization::getWebsite();

        $resources = $website->search($searchString, false, array('page'/* , 'publication' */), false, 6);
        $news = $website->search($searchString, false, array('news', 'event_item', 'press_release'), false, 6);
        $clients = $website->search($searchString, false, array('cf_case_study'), false, 6);
        $solutions = $website->search($searchString, false, array('cf_solution'), false, 6);
        $projects = $website->search($searchString, false, array('project'), false, 6);

        /** Fixes uris for the different types of solutions */
        /*
        $parentUri = array(
            'carbon' => 'carbon-management',
            'energy' => 'onsite-energy-efficiency',
            'farming' => 'australian-carbon-farming'
        );
        foreach ($solutions as $solution) {
            $uriParts = explode('/', $solution->uri);
            $solution->uri = str_replace($uriParts[1], $parentUri[$uriParts[1]], $solution->uri);
        }
        */

        $results = array();

        if (!empty($resources)) {
            $results[] = array(
                'group' => 'resources',
                'groupLabel' => trans('frontend.resources'),
                'linkLabel' => trans('frontend.see_all').' '.trans('frontend.resources'),
                'items' => $resources
            );
        }
        if (!empty($news)) {
            $results[] = array(
                'group' => 'news',
                'groupLabel' => trans('frontend.news_and_events'),
                'linkLabel' => trans('frontend.see_all').' '.trans('frontend.news_and_events'),
                'items' => $news
            );
        }
        if (!empty($clients)) {
            $results[] = array(
                'group' => 'clients',
                'groupLabel' => trans('frontend.clients'),
                'linkLabel' => trans('frontend.see_all').' '.trans('frontend.clients'),
                'items' => $clients
            );
        }
        if (!empty($solutions)) {
            $results[] = array(
                'group' => 'solutions',
                'groupLabel' => trans('frontend.solutions'),
                'linkLabel' => trans('frontend.see_all').' '.trans('frontend.solutions'),
                'items' => $solutions
            );
        }
        if (!empty($projects)) {
            $results[] = array(
                'group' => 'projects',
                'groupLabel' => trans('frontend.projects'),
                'linkLabel' => trans('frontend.see_all').' '.trans('frontend.projects'),
                'items' => $projects
            );
        }

        return response()->json($results);
    }

    public function postDownload()
    {
        $validator = Validator::make(
            request()->all(),
            array(
                'download_id' => 'required|integer|min:1'
            )
        );
        if ($validator->fails()) {
            return response()->json(array(
                "error" => "validation",
                "description" => "bad syntax",
                "validation" => $validator->messages()
            ), 400);
        }

        $visitor = null;
        $downloadId = request()->input('download_id');
        $website = Localization::getWebsite();
        $token = request()->cookie('visitor_token');

        if ($token) {
            //Looks if token belongs to a website user
            $visitor = $website->getVisitorByToken($token);
        }

        // If website has tracked pages conversions are made trough Sugar
        if (!$visitor && !$website->track_pages) {
            return response()->json(array(
                "status" => "not_visitor",
            ), 200);
        } else {
            return response()->json(array(
                "status" => "success",
            ), 200);
        }
    }

    public function getDownloadRequest($downloadId)
    {
        if (!$downloadId || !is_numeric($downloadId)) {
            abort(404);
        }
        $token = request()->cookie('visitor_token');
        $website = Localization::getWebsite();
        $visitor = null;
        if ($token) {
            //Looks if token belongs to a website user
            $visitor = $website->getVisitorByToken($token);
        }

        if (!$visitor && !$website->track_pages) {
            abort(404);
        }


        $pub = Publication::full()
            ->where('id', $downloadId)
            ->with(array(
                'document' => function ($query) {
                    $query->where('publication_media_item.language_id', Localization::getActiveLocale());
                }
            ))->first();

        if ($pub) {
            if (!$website->track_pages) {
                $newDownload = new VisitorDownload(array('publication_id' => $pub->id));
                $visitor->downloads()->save($newDownload);
            }
            $doc = $pub->document->get(0);
            if (!$doc) {
                abort(404);
            }

            return Storage::download(config('path.internal.media').'/'.$doc->filename);
        } else {
            abort(404);
        }
    }

    public function postSubmitVisitor()
    {
        $validator = Validator::make(
            request()->all(),
            array(
                'download_id' => 'required|integer|min:1',
                'first_name' => 'required|alpha_num_space|max:30',
                'last_name' => 'required|alpha_num_space|max:30',
                'email' => 'required|email|max:255',
                'subscribe' => 'boolean',
                'organisation' => 'required|max:45',
                'country' => 'required|max:100'
                //  'accept_terms'=> 'required|in:1'
            )
        );
        if ($validator->fails()) {
            return response()->json(array(
                "status" => "validation_errors",
                "validation" => $validator->messages()
            ), 200);
        }
        $website = Localization::getWebsite();
        $downloadId = request()->input('download_id');
        $visitor = array(
            'email' => request()->input('email'),
            'first_name' => request()->input('first_name'),
            'last_name' => request()->input('last_name'),
            'asked_for_nl' => request()->input('subscribe'),
            'company' => request()->input('organisation'),
            'country' => request()->input('country'),
            'website_id' => $website->id
        );

        $existingVisitor = Visitor::where('email', $visitor['email'])
            ->where('website_id', $website->id)->first();
        if ($existingVisitor) {
            $existingVisitor->first_name = $visitor['first_name'];
            $existingVisitor->last_name = $visitor['last_name'];
            $existingVisitor->country = $visitor['country'];
            $existingVisitor->asked_for_nl = $visitor['asked_for_nl'];
            $existingVisitor->company = $visitor['company'];
            $existingVisitor->save();
        } else {
            $existingVisitor = Visitor::create($visitor);
        }

        if ($existingVisitor->asked_for_nl) {
            $result = $this->_mailChimpSubscribe(request()->all());
        }

        //Create a new token
        $newToken = new VisitorToken(array('token' => random_string('sha1')));
        $existingVisitor->tokens()->save($newToken);
        $cookie = cookie()->forever('visitor_token', $newToken->token);

        return response()->json(array(
            "status" => "success"
        ), 200)->withCookie($cookie);
    }

    private function _subscribeVisitor($visitor)
    {
        $subs = NewsletterSubscription::findByEmail($visitor->email);

        if (!$subs) {
            $website = Localization::getWebsite();
            $subs = new NewsletterSubscription();
            $subs->website_id = $website->id;
            $subs->email = $visitor->email;
            $subs->visitor_id = $visitor->id;

            $subs->save();
        }
        if (!$subs->sugar_subscribed) {
            $this->_sugarSubscribe($subs);
        }
        return $subs;
    }

    private function _mailChimpSubscribe($subs, $isComplete = true)
    {
        $apiKey = config('app.mailchimp.apiKey');
        $listId = config('app.mailchimp.listId');
        $mailchimp = new Mailchimp($apiKey);

        return $mailchimp->subscribeToList($listId, $subs, $isComplete);
    }

    private function _sugarSubscribe($subs)
    {
        $data = array();
        $data['first_name'] = $subs->first_name;
        $data['last_name'] = $subs->last_name;
        $data['email1'] = $subs->email;
        $data['newsletter_l_c'] = "on";
        $data['campaign_id'] = config('app.sugar.campaign_id');
        $data['assigned_user_id'] = config('app.sugar.assign_user_id');

        $curl = curl_init();
        curl_setopt($curl, CURLOPT_URL, config('app.sugar.endpoint'));
        curl_setopt($curl, CURLOPT_POST, sizeof($data));
        curl_setopt($curl, CURLOPT_POSTFIELDS, $data);
        curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);
        $result = curl_exec($curl);
        if (curl_getinfo($curl, CURLINFO_HTTP_CODE) == 200) {
            $subs->sugar_subscribed = true;
            $subs->save();
        }
        curl_close($curl);
    }

    public function postSubscribeNewsletterSimple()
    {
        $validator = Validator::make(
            request()->all(),
            array(
                'email' => 'required|email|max:255'
            )
        );
        if ($validator->fails()) {
            return response()->json(array(
                "status" => "validation_errors",
                "validation" => $validator->messages()
            ), 200);
        }
        $subs = NewsletterSubscription::findByEmail(request()->input('email'));

        $visitor = Visitor::findByEmail(request()->input('email'));

        if (!$subs) {
            $website = Localization::getWebsite();
            $subs = new NewsletterSubscription();
            $subs->website_id = $website->id;
            $subs->email = request()->input('email');

            if ($visitor) {
                $visitor->asked_for_nl = true;
                $subs->visitor_id = $visitor->id;
            }

            $subs->save();

            if ($visitor) {
                $visitor->save();
            }
        }

        $result = $this->_mailChimpSubscribe(request()->all(), false);
        if ($result) {
            return response()->json(array(
                "status" => "success"
            ), 200);
        } else {
            return response()->json(array(
                "status" => "error"
            ), 200);
        }
    }

    public function postSubscribeNewsletter()
    {
        $validator = Validator::make(
            request()->all(),
            array(
                'email' => 'required|email|max:255',
                'firstName' => 'required|max:45',
                'lastName' => 'required|max:45',
                'organisation' => 'required|max:45',
                'country' => 'required|max:100'
            )
        );
        if ($validator->fails()) {
            return response()->json(array(
                "status" => "validation_errors",
                "validation" => $validator->messages()
            ), 200);
        }
        $subs = NewsletterSubscription::findByEmail(request()->input('email'));

        $visitor = Visitor::findByEmail(request()->input('email'));

        if (!$subs) {
            $website = Localization::getWebsite();
            $subs = new NewsletterSubscription ();
            $subs->website_id = $website->id;
            $subs->email = request()->input('email');

            if (!$visitor) {
                $visitor = new Visitor();
                $visitor->email = request()->input('email');
                $visitor->website_id = $website->id;
            }

            $visitor->first_name = request()->input('firstName');
            $visitor->last_name = request()->input('lastName');
            $visitor->company = request()->input('organisation');
            $visitor->country = request()->input('country');
            $visitor->asked_for_nl = true;

            $visitor->save();
            $subs->visitor_id = $visitor->id;

            $subs->save();
        }

        $result = $this->_mailChimpSubscribe(request()->all());
        if ($result) {
            return response()->json(array(
                "status" => "success"
            ), 200);
        } else {
            return response()->json(array(
                "status" => "error"
            ), 200);
        }
    }

    public function postSendContact()
    {
        $validator = Validator::make(
            request()->all(),
            array(
                'email' => 'required|email|max:255',
                'firstName' => 'required|max:45',
                'lastName' => 'required|max:45',
                'organisation' => 'required|max:45',
                'country' => 'required|max:100',
                'message' => 'required|max:5000',
                'contactId' => 'required|integer',
                'pageUrl' => 'url',
                'g-recaptcha-response' => 'required'
            )
        );
        if ($validator->fails()) {
            return response()->json(array(
                "status" => "validation_errors",
                "validation" => $validator->messages()
            ), 200);
        }

        if (!$this->checkRecaptcha(request()->input('g-recaptcha-response'))) {
            return response()->json(array(
                "status" => "validation_errors",
                "validation" => array(
                    'g-recaptcha-response' => 'Captcha verification Failed'
                )
            ), 200);
        }

        $visitor = Visitor::findByEmail(request()->input('email'));
        $website = Localization::getWebsite();

        if (!$visitor) {
            $visitor = new Visitor();
            $visitor->email = request()->input('email');
            $visitor->website_id = $website->id;
        }

        $visitor->first_name = request()->input('firstName');
        $visitor->last_name = request()->input('lastName');
        $visitor->company = request()->input('organisation');
        $visitor->country = request()->input('country');
        $visitor->save();

        $contact = Contact::find(request()->input('contactId'));
        if (!$contact) {
            return response()->json(array(
                "status" => "error"
            ), 400);
        }

        $visitorContact = new VisitorContact();
        $visitorContact->visitor_id = $visitor->id;
        $visitorContact->contact_id = $contact->id;
        $visitorContact->message = htmlentities(request()->input('message'));
        $visitorContact->page_url = request()->input('pageUrl');
        $visitorContact->save();

        $visitorContact->load(['contact', 'visitor']);

        $this->sendContactEmail($visitorContact);

        return response()->json(array(
            "status" => "success"
        ), 200);
    }
/*
    public function postSubmitVacancy()
    {
        $data = [
            'job_id' => request()->input('job_id'),
            'first_name' => request()->input('first_name'),
            'last_name' => request()->input('last_name'),
            'nationality' => request()->input('nationality'),
            'location' => request()->input('location'),
            'email' => request()->input('email'),
            'phone' => request()->input('phone'),
            'abstract' => request()->input('abstract'),
            'permit' => request()->input('permit'),
            'permit_details' => request()->input('permit_details'),
            'cv' => request()->file('cv'),
            'cl' => request()->file('cl'),
            'g-recaptcha-response' => request()->input('g-recaptcha-response'),
            'salary_currency' => request()->input('salary_currency'),
            'salary' => request()->input('salary'),
            'source' => request()->input('source'),
            'source_text' => request()->input('source_text'),
            'based_in' => request()->input('based_in'),
        ];

        $rules = array(
            'job_id' => 'required|integer',
            'first_name' => 'required|alpha_num_space_plus|max:50',
            'last_name' => 'required|alpha_num_space_plus|max:50',
            'nationality' => 'required|alpha_num_space_plus|max:50',
            'location' => 'required|alpha_num_space_plus|max:50',
            'email' => 'required|email|max:255',
            'phone' => 'required|alpha_num_space_plus|max:50',
            'abstract' => 'required|max:500',
            'permit' => 'required|in:Yes,No',
            'permit_details' => 'alpha_num_space_plus|max:200',
            'cv' => 'required|mimes:pdf,doc,docx|max:2048',
            'cl' => 'mimes:pdf,doc,docx|max:2048',
            'g-recaptcha-response' => 'required',
            'based_in' => 'required',
            'salary_currency' => 'required',
            'salary' => 'required|numeric',
            'source' => 'required',
            'source_text' => 'required_if:source,referral,agency,job_board|max:500'
        );

        $validator = Validator::make(
            $data,
            $rules
        );

        if ($validator->fails()) {
            return response()->json(array(
                "status" => "validation_errors",
                "validation" => $validator->messages(),
                "message" => trans("There are validation errors. Please check the highlighted fields.")
            ), 200);
        }

        if (!$this->checkRecaptcha(request()->input('g-recaptcha-response'))) {
            return response()->json(array(
                "status" => "validation_errors",
                "validation" => array(
                    'g-recaptcha-response' => 'Captcha verification Failed'
                )
            ), 200);
        }

        $job = JobOffer::full()
            ->with(array('office'))
            ->where("id", request()->input('job_id'))
            ->first();

        if (!$job || $job->status != 'published') {
            return response()->json(array(
                "status" => "validation_errors",
                "validation" => array(
                    'job_id' => 'Job not found'
                ),
                "message" => __("Job offer not found. Please contact us")
            ), 200);
        }


        $candidate = VacancyCandidate::where('email', request()->input('email'))
            ->first();

        if (!$candidate) {
            $candidate = new VacancyCandidate();
            $candidate->email = request()->input('email');
            $candidate->application_count = 0;
            $candidate->save();
        }

        $application = new VacancyApplication();

        $application->job_id = request()->input('job_id');
        $application->first_name = request()->input('first_name');
        $application->last_name = request()->input('last_name');
        $application->nationality = request()->input('nationality');
        $application->location = request()->input('location');
        $application->email = request()->input('email');
        $application->phone = request()->input('phone');
        $application->abstract = request()->input('abstract');
        $application->permit = request()->input('permit') == 'Yes';
        $application->permit_details = request()->input('permit_details');
        $application->vacancy_candidate_id = $candidate->id;
        $application->based_in = ucwords(str_replace('_', ' ', request()->input('based_in')));
        $application->salary_currency = request()->input('salary_currency');
        $application->salary = request()->input('salary');
        $application->position_source_text = ucwords(str_replace('_', ' ', request()->input('source')));
        $application->other_text = request()->input('source_text');

        $application->save();

        $folderName = "Job ".$application->job_id;

        $folderId = $this->searchFolder($folderName);
        if (!$folderId) {
            $folderId = $this->createFolderDrive($folderName);
        }
        if (request()->hasFile('cv')) {
            $file = request()->file('cv');
            $filename = "Job ".$application->job_id." - CV - "
                .$application->first_name." "
                .$application->last_name
                .'.'.$file->getClientOriginalExtension();
            $application->cv_link = $this->uploadFileDrive($file, $filename, $folderId);
        }
        if (request()->hasFile('cl')) {
            $file = request()->file('cl');
            $filename = "Job ".$application->job_id." - CL - "
                .$application->first_name." "
                .$application->last_name
                .'.'.$file->getClientOriginalExtension();
            $application->cl_link = $this->uploadFileDrive($file, $filename, $folderId);
        }
        $application->save();

        $success = $this->sendVacancy($application, $job);
        $application->success = $success;
        $candidate->application_count = $candidate->application_count + 1;
        $application->save();
        $candidate->save();

        if ($success) {
            $this->sendVacancyEmail($application, $job);
            return response()->json(array(
                "status" => "success"
            ), 200);
        } else {
            return response()->json(array(
                "status" => "error",
                "message" => "Error submiting application. Please contact us if the problem persists."
            ), 200);
        }
    }
*/
    private function checkRecaptcha($recaptchaResponse)
    {
        $secret = config('google.recaptcha.secretKey');
        $remoteIp = request()->getClientIp();
        $recaptcha = new ReCaptcha($secret);
        $resp = $recaptcha->verify($recaptchaResponse, $remoteIp);
        if ($resp->isSuccess()) {
            return true;
        } else {
            //$errors = $resp->getErrorCodes();
            return false;
        }
    }
/*
    private function sendVacancy($vacancy, $job)
    {

        $host = config('app.spgVacancyApp.url');
        $username = config('app.spgVacancyApp.username');
        $password = config('app.spgVacancyApp.password');

        $process = curl_init($host);

        $content = [
            'vacancy' => [
                'id' => $job->id,
                'title' => $job->title,
                'type' => 'External',
                'location' => $job->flexible_location ? 'Location flexible' : ($job->office ? $job->office->title : ''),
                'creation_date' => substr($job->created_at, 0, 10)
            ],
            'candidate' => [
                //'id' => $vacancy->vacancy_candidate_id,
                'email' => $vacancy->email,
                'first_name' => $vacancy->first_name,
                'last_name' => $vacancy->last_name,
                'nationality' => $vacancy->nationality,
                'location' => $vacancy->location,
                'phone' => $vacancy->phone,
                'abstract' => $vacancy->abstract,
                'cv_link' => $vacancy->cv_link,
                'cl_link' => $vacancy->cl_link,
                'work_permit' => $vacancy->permit,
                'permit_details' => $vacancy->permit_details,
                'based_in' => $vacancy->based_in,
                'salary_currency' => $vacancy->salary_currency,
                'salary' => $vacancy->salary,
                'position_source_text' => $vacancy->position_source_text,
                'other_text' => $vacancy->other_text
            ]
        ];

        $content = json_encode($content);
        $vacancy->spg_api_request = $content;

        curl_setopt($process, CURLOPT_HTTPHEADER, array(
            'Content-Type: application/json; charset=utf-8',
        ));
        curl_setopt($process, CURLOPT_CUSTOMREQUEST, "POST");
        //curl_setopt($process, CURLOPT_VERBOSE, true);
        //curl_setopt($process, CURLOPT_HEADER, 1);
        //curl_setopt($process, CURLOPT_SSL_VERIFYHOST, 0);
        curl_setopt($process, CURLOPT_USERPWD, $username.":".$password);
        curl_setopt($process, CURLOPT_TIMEOUT, 30);
        curl_setopt($process, CURLOPT_POST, 1);
        curl_setopt($process, CURLOPT_POSTFIELDS, $content);
        curl_setopt($process, CURLOPT_RETURNTRANSFER, true);

        $return = curl_exec($process);

        curl_close($process);

        $vacancy->spg_api_reply = $return;

        $reply = json_decode($return, true);

        return $reply && isset($reply['vacancy_id']);
    }

    protected function createFolderDrive($foldername)
    {
        $folderId = config('google.vacanciesAppsFolderId');
        $drive = Google::make('drive');
        $fileMetadata = new Google_Service_Drive_DriveFile(array(
            'name' => $foldername,
            'parents' => array($folderId),
            'mimeType' => 'application/vnd.google-apps.folder'
        ));

        $file = $drive->files->create($fileMetadata, array(
            'fields' => 'id'
        ));

        return $file->id;
    }

    protected function searchFolder($foldername)
    {
        $folderId = config('google.vacanciesAppsFolderId');
        $drive = Google::make('drive');
        $q = "name = '$foldername'";
        $q .= " and mimeType = 'application/vnd.google-apps.folder'";
        $q .= " and '$folderId' in parents";

        $files = $drive->files->listFiles(array(
            'q' => $q,
            'spaces' => 'drive',
            'fields' => 'files(id, name)'
        ));
        $foundId = null;
        foreach ($files as $f) {
            $foundId = $f->id;
            break;
        }
        return $foundId;
    }

    protected function uploadFileDrive($file, $filename, $folderId)
    {
        //$googleClient = Google::getClient();
        //$folderId = config('google.vacanciesAppsFolderId');
        $drive = Google::make('drive');

        $fileMetadata = new Google_Service_Drive_DriveFile(array(
            'name' => $filename,
            'parents' => array($folderId)
        ));
        $content = file_get_contents($file->getRealPath());
        $file = $drive->files->create($fileMetadata, array(
            'data' => $content,
            'mimeType' => $file->getMimeType(),
            'uploadType' => 'multipart',
            'fields' => 'id,webViewLink'
        ));

        return $file->webViewLink;
    }

    private function sendVacancyEmail($vacancy, $job)
    {
        $placeholders = [
            'job_id' => $job->id,
            'candidate_id' => $vacancy->vacancy_candidate_id,
            'first_name' => $vacancy->first_name,
            'last_name' => $vacancy->last_name,
            'job_title' => $job->title
        ];
        $mailTemplate = MailTemplate::full()
            ->where("lang_slug", 'job-application-confirmation-email')->first();

        if (!$mailTemplate) {
            return;
        }
        $subject = $mailTemplate->subject;
        $content = $mailTemplate->content;
        foreach ($placeholders as $placeholder => $value) {
            if ($subject) {
                $subject = str_replace('['.$placeholder.']', $value, $subject);
            }
            if ($content) {
                $content = str_replace('['.$placeholder.']', $value, $content);
            }
        }

        $website = Localization::getWebsite();

        Mail::send('emails.job_application_confirmation', array('website' => $website, 'content' => $content),
            function ($message) use ($vacancy, $subject) {
                $message->to($vacancy->email, $vacancy->first_name.' '.$vacancy->last_name)
                    ->replyTo(config('app.spgVacancyApp.mailFromAddress'),
                        config('app.spgVacancyApp.mailFrom'))
                    ->from(config('app.spgVacancyApp.mailFromAddress'), config('app.spgVacancyApp.mailFrom'))
                    ->subject($subject);
            });
    }
*/
    private function sendContactEmail($visitorContact)
    {

        $contact = $visitorContact->contact;
        $website = Localization::getWebsite();

        Mail::to($contact->email, $contact->contact_name)->send(new ContactMail($visitorContact, $website));
    }

    public function postSubmitAssessment()
    {
        $data = [
            'first_name' => request()->input('first_name'),
            'last_name' => request()->input('last_name'),
            'job_title' => request()->input('job_title'),
            'company' => request()->input('company'),
            'assessment_email' => request()->input('assessment_email'),
            'site_name' => request()->input('site_name'),
            'site_country' => request()->input('site_country'),
            'industry_sector' => request()->input('industry_sector'),
            'location_found' => request()->input('location_found'),
            'location_lat' => request()->input('location_lat'),
            'location_lng' => request()->input('location_lng'),
            'rooftop_size' => request()->input('rooftop_size'),
            'electricity_consumption' => request()->input('electricity_consumption'),
            'g-recaptcha-response' => request()->input('g-recaptcha-response'),
            'is_upload' => request()->input('is_upload'),
        ];

        $filters = [
            'first_name' => 'strip_tags|xss_clean|trim',
            'last_name' => 'strip_tags|xss_clean|trim',
            'job_title' => 'strip_tags|xss_clean|trim',
            'company' => 'strip_tags|xss_clean|trim',
            'assessment_email' =>'strip_tags|xss_clean|trim',
            'site_name' => 'strip_tags|xss_clean|trim',
            'site_country' => 'strip_tags|xss_clean|trim',
            'industry_sector' => 'strip_tags|xss_clean|trim',
            'location_found' => 'strip_tags|xss_clean|trim',
            'location_lat' => 'strip_tags|xss_clean|trim',
            'location_lng' => 'strip_tags|xss_clean|trim',
            'rooftop_size' => 'strip_tags|xss_clean|trim|empty_string_to_null',
            'electricity_consumption' => 'strip_tags|xss_clean|trim|empty_string_to_null',
            'is_upload' => 'strip_tags|xss_clean|trim',
        ];

        $sanitizer = new Sanitizer($data, $filters);
        $data = $sanitizer->sanitize();

        $rules = array(
            'first_name' => 'required|max:30',
            'last_name' => 'required|max:30',
            'job_title' => 'required|max:60',
            'company' => 'required|max:60',
            'assessment_email' => 'required|email|max:255',
            'site_name' => 'required|max:60',
            'site_country' => 'required|max:60',
            'industry_sector' => 'required_if:is_upload,0|max:60',
            'location_found' => 'required|max:200',
            'location_lat' => 'required|numeric',
            'location_lng' => 'required|numeric',
            'rooftop_size' => 'nullable|numeric',
            'electricity_consumption' => 'nullable|required_if:is_upload,0|numeric',
            'load_profile' => 'file|mimes:pdf,doc,docx,jpg,png,txt,csv|max:2048',
            'g-recaptcha-response' => 'required',
            'is_upload' => 'required|in:1,0'
        );

        $validator = Validator::make(
            $data,
            $rules
        );

        if ($validator->fails()) {
            return response()->json(array(
                "status" => "validation_errors",
                "validation" => $validator->messages(),
                "message" => trans("There are validation errors. Please check the highlighted fields.")
            ), 200);
        }

        if (!request()->hasFile('load_profile') && $data['is_upload'] == '1') {
            return response()->json(array(
                "status" => "validation_errors",
                "validation" => array('load_profile' => array('Load profile is required')),
                "message" => trans("There are validation errors. Please check the highlighted fields.")
            ), 200);
        }

        if (!$this->checkRecaptcha(request()->input('g-recaptcha-response'))) {
            return response()->json(array(
                "status" => "validation_errors",
                "validation" => array(
                    'g-recaptcha-response' => 'Captcha verification Failed'
                )
            ), 200);
        }

        $filename = null;
        if (request()->hasFile('load_profile')) {
            $file = request()->file('load_profile');
            $filename = random_string('alnum', 20).'.'.$file->getClientOriginalExtension();
            $file->storeAs(
                '',
                $filename,
                'assessment_profiles'
            );
        }

        $assessment = new Assessment();
        $assessment->first_name = $data['first_name'];
        $assessment->last_name = $data['last_name'];
        $assessment->job_title = $data['job_title'];
        $assessment->company = $data['company'];
        $assessment->email = $data['assessment_email'];
        $assessment->site_name = $data['site_name'];
        $assessment->country = $data['site_country'];
        $assessment->location = $data['location_found'];
        $assessment->location_lat = substr($data['location_lat'], 0, 10);
        $assessment->location_lng = substr($data['location_lng'], 0, 10);
        $assessment->industry_sector = $data['industry_sector'];
        $assessment->rooftop_size = $data['rooftop_size'];
        $assessment->electricity_consumption = $data['electricity_consumption'];
        $assessment->load_profile = $filename;

        $assessment->save();

        $this->sendAssessmentEmail($assessment);

        return response()->json(array(
            "status" => "success"
        ), 200);
    }

    private function sendAssessmentEmail($assessment)
    {
        $website = Localization::getWebsite();

        Mail::to(
            config('mail.addresses.assessments.email'),
            config('mail.addresses.assessments.name')
        )->send(new AssessmentReceived($assessment, $website));
    }
}