export class MyBackground extends Coveo.Component {
  constructor(element, options, bindings, result) {
    super(element, MyBackground.ID);
    this.result = result;
    this.element = element;
    this.options = Coveo.ComponentOptions.initComponentOptions(element, MyBackground, options);
    if (this.options.showPoster) {
      this.addImage();
    }
    let colors = result.raw.mycolors;
    if (colors) {
      this.addColors(colors);
    } else {
      this.addTopBorder(element);
    }
  }

  addImage() {
    let url = this.result.raw.myimage;
    let imagesPerTypeMap = {
      Movie: `//image.tmdb.org/t/p/w185_and_h278_bestv2/${url}`,
      Music: `//lastfm-img2.akamaized.net/i/u/174s/${url}`,
      Concert: `//images.sk-static.com/images/media/profile_images/artists/${url}/large_avatar`,
      People: `//image.tmdb.org/t/p/w138_and_h175_face${url}`,
      'Movie People': `//image.tmdb.org/t/p/w138_and_h175_face${url}`
    };

    let imageUrl = imagesPerTypeMap[this.result.raw.mytype];
    if (imageUrl && !url) {
      // right type (Movie, Music, Concert) but a specific image wasn't set.
      imageUrl = '//elastic.coveodemo.com/icons/noimage-nofill.png';
    }
    $(this.element)
    .closest('.coveo-result-frame')
    .css('background-image', `url(${imageUrl})`)
    .on('click', e => {
        $(e.target)
        .find('.CoveoQuickview')
        .coveo('open');
    });
  }

  addColors(colors) {
    colors = colors.split(' ');
    if (colors.length) {
      let i = 0;
      // make sure we have at least 5 colors, by repeating previous colors when array is short.
      while (colors.length < 5) {
        colors.push(colors[i++]);
      }
      colors = colors.map((c, idx) => {
        let trans = 0.05;
        if (this.options.showPoster) {
          trans = 0.2;
        }

        let t = ((5 - idx) * trans).toFixed(2);
        return c.replace('(', 'rgba(').replace(')', `,${t})`); // add transparency
      });

      let gradient = `linear-gradient(to right, ${colors[0]}, ${colors[1]}), radial-gradient(circle, ${colors[2]}, ${colors[3]}, ${
        colors[4]
      })`;

      this.addTopBorder(this.element, gradient);
    }
  }

  /**
   * Sets the baackground gradient on a border
   * @param {domElement} element
   * @param {string?} gradient (optional) CSS for background's gradient
   */
  addTopBorder(element, gradient) {
    let backgroundGradient = gradient || 'linear-gradient(45deg, rgba(193,193,193,0.35) 0%,rgba(0,0,0,0) 100%)'; // gradient or default.
    $(element)
      .closest('.CoveoResult')
      .prepend('<div class="TopBorder"></div>')
      .css('background', backgroundGradient);
  }
}

MyBackground.ID = 'MyBackground';
MyBackground.options = {
  showPoster: Coveo.ComponentOptions.buildBooleanOption({ defaultValue: false }),
  showUser: Coveo.ComponentOptions.buildBooleanOption({ defaultValue: false })
};
Coveo.Initialization.registerAutoCreateComponent(MyBackground);

/**
 * ART result
 * Is triggered when ART (Machine Learning) is kicking in
 */
export class MyART extends Coveo.Component {
  constructor(element, options, bindings, result) {
    super(element, MyART.ID);
    if (result.isRecommendation) {
      const badge = this.getBadge();
      const resultFrame = $$(this.element).closest('.coveo-result-frame');
      $$(resultFrame).prepend(badge.el);
    }
  }

  getBadge() {
    const container = this.getBadgeContainer();
    const highlight = this.getBadgeHighlight();
    const text = this.getBadgeText();
    highlight.append(text.el);

    container.append(highlight.el);
    return container;
  }

  getBadgeContainer() {
    const container = $$('div', {
      className: 'custom-coveo-badge'
    });
    container.el.style.position = 'relative';
    return container;
  }

  getBadgeText() {
    const text = $$(
      'div',
      {
        className: 'mytextART'
      },
      'ML Boost'
    );
    return text;
  }

  getBadgeHighlight() {
    const highlight = $$('div', {
      className: 'coveo-result-highlight coveo-custom-ART'
    });

    return highlight;
  }
}

MyART.ID = 'MyART';
Coveo.Initialization.registerAutoCreateComponent(MyART);

//***************************
  //composeQuery
  //  Creates a new query for the checkQuery function
  //***************************
  composeQuery(result, dataset) {
    let newquery = dataset.query;
    let a = dataset.fields.split(';');
    let allfieldsmissing = true;
    for (i = 0; i < a.length; i++) {
      let fieldcontent = result.raw[a[i]];
      if (fieldcontent) {
        allfieldsmissing = false;
        fieldcontent = '' + fieldcontent; //make sure it's a string
        //Seems that if you format the field in the UI, it gets the formatted value
        fieldcontent = fieldcontent.replace(/[;()]/g, ' ');
        //Comma's must be replaced by ","
        fieldcontent = fieldcontent.replace(/,/g, '","');
        //In Elastic the : means a field query
        newquery = newquery.replace('[FIELD' + (i + 1) + ']', fieldcontent.replace(':', ' '));
      } else {
        newquery = newquery.replace('[FIELD' + (i + 1) + ']', '');
      }
    }
    //ugly but for now fine, you would normally do this in a IPE or just before indexing.
    newquery = newquery.replace('movie script - Screenplays for You', '');
    return newquery;
  }

  //***************************
  //checkQuery
  //  Checks the query for all the relatedTabs. Based upon the groupby fields the tab will be made visible or not
  //***************************
  checkQuery(fields, query, partial, dataset) {
    let queryBuilder = new Coveo.QueryBuilder();
    queryBuilder.locale = GetBindings().queryController.lastQueryBuilder.locale;
    queryBuilder.pipeline = 'default';
    queryBuilder.searchHub = 'CheckTabs';
    queryBuilder.enableDebug = false;
    queryBuilder.enableQuerySyntax = true;
    queryBuilder.enableDuplicateFiltering = false;
    queryBuilder.excerptLength = 200;

    queryBuilder.timezone = GetBindings().queryController.lastQueryBuilder.timezone;
    queryBuilder.numberOfResults = 0;
    queryBuilder.groupByRequests = fields;

    queryBuilder.expression.add(query);
    if (partial === 'true') {
      queryBuilder.enablePartialMatch = true;
      queryBuilder.partialMatchKeywords = 4;
      queryBuilder.partialMatchThreshold = '50%';
    }
    GetBindings()
      .queryController.getEndpoint()
      .search(queryBuilder.build())
      .done(function(data) {
        dataset.forEach(f => {
          if (f.dataset.partialMatch === partial && f.dataset.keyCheck) {
            //Check if we have the key in the result, if so enable the tab else disable it
            let value = f.dataset.keyCheck.split(';')[1];
            let found = false;
            data.groupByResults.forEach(res => {
              res.values.forEach(groupval => {
                if (groupval.value.toLowerCase() === value.toLowerCase()) {
                  //We have it
                  found = true;
                }
              });
            });
            let $newTab = $('.RelatedTab[data-name="' + f.tab + '"]', f.parent);
            if (found) {
              $newTab.show();
            } else {
              $newTab.hide();
            }
          }
        });
      });
  }

  doWeHaveIt(tocheck, value) {
    let wehaveit = false;
    $.each(tocheck, function(index, obj) {
      if (obj.field === value) {
        wehaveit = true;
      }
    });
    return wehaveit;
  }

  //***************************
  //  checkQueries
  //  builds up the total query to execute for the relatedTabs
  //***************************
  checkQueries(queries) {
    // Partial match queries
    let checkQueriesWithPartialMatch = partialMatch => {
      let fields = [];
      let query = [];

      queries.forEach(f => {
        if (f.dataset.partialMatch === partialMatch && f.dataset.keyCheck) {
          // Build a single query with an OR on all queries
          // The key will be used to check if we have results
          // Add keyfield to fields to retrieve
          let field = f.dataset.keyCheck.split(';')[0];
          if (!this.doWeHaveIt(fields, field)) {
            fields.push({ field, sortCriteria: 'nosort' });
          }
          query.push('(' + this.composeQuery(f.result, f.dataset) + ')');
        }
      });
      if (query.length) {
        this.checkQuery(fields, query.join(' OR '), partialMatch, queries);
      }
    };

    checkQueriesWithPartialMatch('true');
    checkQueriesWithPartialMatch('false');
  }

//Create a usermap with help and booster information.
const usersMap = {
  Producer: {
    sel: "Producer",
    activeTab: "Movies",
    booster: "$qre(expression: \'@mytype=Movie\',modifier:\'1600\', isConstant:\'true\') $qre(expression: \'@mygenre=Documentaries @mytype=Movie\',modifier:\'400\', isConstant:\'true\')  $qre(expression: \'@mygenre=Rock @mytype=Music\',modifier:\'-420\', isConstant:\'true\') $qre(expression: \'@myprofitvalue<=5\',modifier:\'-800\', isConstant:\'true\') $qre(expression: \'@myprofitvalue>100\',modifier:\'200\', isConstant:\'true\') ",
    musicbooster: " $qre(expression: \'@mygenre=Rock @mytype=Music\',modifier:\'-500\', isConstant:\'true\')",
  },
  Anonymous: {
    sel: "Anonymous",
    activeTab: "Movies",
    booster: "$qre(expression: \'@mytype=Movie\',modifier:\'1600\', isConstant:\'true\') $qre(expression: \'@mytype=Review\',modifier:\'-1200\', isConstant:\'true\') $qre(expression: \'@mypopularity<15\', modifier:\'-800\', isConstant:\'true\') $qre(expression: \'@mypopularity>15\', modifier:\'200\', isConstant:\'true\') $qre(expression: \'@mypopularity>250\', modifier:\'200\', isConstant:\'true\') $qre(expression: \'@mypopularity>500\', modifier:\'200\', isConstant:\'true\')",
    musicbooster: "",
  }
};

$('#search').on("buildingQuery", function (e, args) {
	//A custom context is added so we can react on it in Query Pipelines and Analytics
	args.queryBuilder.addContext({
		"userRole": userIdToAdd.sel
	});
});

$('#search').on("buildingQuery", function (e, args) {
	//Set the proper pipeline
	args.queryBuilder.pipeline = (MLactive ? 'ML' : 'default');

	if (userBoost) {
		Coveo.$('.CoveoSearchInterface').coveo('state', 'hd', userHelp.split('<BR>')[0]);
		Coveo.$('.CoveoSearchInterface').coveo('state', 'hq', userBoost);
		userBoost = "";
	}
});

'use strict';
const https = require('https');

const TOKENS = {
  'platformdemoelastic3zlf3f2p': '-IMPERSONATE-TOKEN-'
};

const ROLES = {
  Director: 'director@coveo.com',
  Producer: 'producer@coveo.com',
  Rock: 'rock@coveo.com'
};


let getUsers = (role) => {
  let provider = 'Email Security Provider';
  let users = [{
    name: '*@*',
    provider,
    type: 'Group'
  }];

  let name = ROLES[role];
  if (name) {
    users.push({
      name,
      provider,
      type: 'User',
    });
  }
  return users;
};


// Return an object {token, userIds?} if input is valid, otherwise returns null.
let validateInput = (event) => {
  try {
    let body = JSON.parse(event.body),
      token = TOKENS[body.org],
      userIds = getUsers(body.role);

    if (token && userIds) {
      return { token, userIds };
    }
  }
  catch (e) {
    console.log('Invalid input: ', e);
  }
  return null;
};


let requestToken = (inputParams, callback) => {
  // the post options
  let options = {
    host: 'platform.cloud.coveo.com',
    path: '/rest/search/token',
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'Authorization': 'Bearer ' + inputParams.token,
    }
  };

  let req = https.request(options, (res) => {
    if (res.statusCode !== 200) {
      callback(res);
      return;
    }
    let body = '';
    res.on('data', chunk => {body += chunk;});
    res.on('end', () => {
      let response = {
        statusCode: 200,
        headers: {
          'Access-Control-Allow-Headers': 'Content-Type,X-Amz-Date,Authorization,X-Api-Key,X-Amz-Security-Token',
          'Access-Control-Allow-Methods': 'POST,OPTIONS',
          'Access-Control-Allow-Origin': '*',
        },
        body,
        isBase64Encoded: false
      };

      // success
      callback(null, response);
    });
  });
  req.on('error', (e) => {
    console.error('HTTP error: ' + e.message);
    callback({
      statusCode: 500,
      headers: {},
      body: '{"message":"server error"}',
      isBase64Encoded: false
    });
  });

  let usersPayload = {
    userIds: inputParams.userIds
  };
  req.write(JSON.stringify(usersPayload));
  req.end();

};

exports.handler = (event, context, callback) => {
  let inputParams = validateInput(event);
  if (inputParams) {
    requestToken(inputParams, callback);
  }
  else {
    callback(null, {
      statusCode: 400,
      headers: {},
      body: '{"message": "Invalid request body"}',
      isBase64Encoded: false
    });
  }

};

//On Load...

  //We set default values
  Coveo.Analytics.options.endpoint.defaultValue = 'https://usageanalytics.coveo.com';
  Coveo.Analytics.options.searchHub.defaultValue = 'Movie';
  Coveo.Analytics.options.organization.defaultValue = ORG_ID;
  Coveo.Analytics.options.pipeline = 'ML';

  //Retrieve the access token
  let xhr = new XMLHttpRequest();
  xhr.open('POST', 'https://5qgxnbkr4f.execute-api.us-east-1.amazonaws.com/prod');
  xhr.setRequestHeader('Content-Type', 'application/json');
  xhr.onload = ()=>{
    let token = JSON.parse(xhr.response).token;
    //Set it for both the interface as the analytics token
    Coveo.SearchEndpoint.endpoints['default'].options.accessToken = token;
    Coveo.Analytics.options.token.defaultValue = token;
    //Init our Components
    Coveo.init(document.querySelector('#search'));
    //And the recommendation component
    Coveo.initRecommendation(document.querySelector('#MyRecommendationsMusic'));
  };
  xhr.send(JSON.stringify({
    org: ORG_ID,
    role: userIdToAdd.sel
  }));

export class MyPopularQueries extends Coveo.Component {
  constructor(element) {
    super(element, MyPopularQueries.ID);
    ['Jungle Book', 'Fast Racing', 'Upcoming', 'Playing now', 'Suprise me', 'History Museum'].forEach(value => {
      const link = this.buildLink(value);
      Coveo.$$(this.element).append(link.el);
    });
  }

  buildLink(value) {
    const link = Coveo.$$('a', { href: '#' }, value);
    link.on('click', e => {
      e.preventDefault();
      this.changeQuery(value);
    });

    return link;
  }

  changeQuery(query) {
    Coveo.state(this.root, 'q', query);
    const customEventCause = { name: 'searchboxSubmit', type: 'search box' };
    Coveo.logSearchEvent(this.root, customEventCause, {});
    Coveo.executeQuery(this.root);
  }
}

MyPopularQueries.ID = 'MyPopularQueries';
Coveo.Initialization.registerAutoCreateComponent(MyPopularQueries);

$('#search').on("preprocessResults", (e, args) => {
  //We want to add an additional field (if it is missing) to the results
  ((args && args.results && args.results.results) || []).forEach(r=>{
    r.raw.collection = (r.raw.collection || 'default');
  });
});

//Setting the translation for the custom strings, which would not be in the out-of-the-box translation set
String.toLocaleString({
  "es-es": {
    "Movies, Scripts and Music": "Películas, guiones y música",       
    "All Content": "Todo el contenido",
    "Type": "Tipo",
    "Genre": "Género",
    "Artist (Soundtrack)": "Artista (Banda sonora)",
  },
  "nl": {
    "Movies, Scripts and Music": "Films, script en Muziek",       
    "All Content": "Alles",
    "Type": "Type",
    "Genre": "Genre",
    "Artist (Soundtrack)": "Artiest (soundtrack)",
  },
  "fr": {
    "Movies, Scripts and Music": "Films, Scripts et Musique",       
    "All Content": "Tout le contenu",
    "Type": "Type",
    "Genre": "Genre",
    "Artist (Soundtrack)": "Artist (soundtrack)",
  }
});

//Setting the locale based upon es-es, nl, fr, en
Globalize.cultureSelector = id;
String["locale"] = id;
//Reload the window
window.location.reload();

function toTitleCase(str) {
  return str.replace(/\w\S*/g, function(txt) {
    return txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase();
  });
}

function handleQuerySuggestResponse(response) {
  let queries = response.completions || [];
  queries = queries.map(q => toTitleCase(q.expression));

  Coveo.load('MyPopularQueries').then(MyPopularQueries => {
    return new MyPopularQueries(document.getElementById('PopularQueries'), { queries }, GetBindings());
  });
}

function getQuerySuggest(profile) {
  var token = Coveo.SearchEndpoint.endpoints['default'].options.accessToken;
  var url =
    'https://platform.cloud.coveo.com/rest/search/v2/querySuggest?' +
    'access_token=' +
    token +
    '&language=en' +
    ' &pipeline=MLIntranet' +
    '&context={"userrole": "' +
    profile +
    '"}' +
    '&searchHub=Intranet';

  var xhr = new XMLHttpRequest();
  xhr.addEventListener('load', function() {
    handleQuerySuggestResponse(JSON.parse(this.responseText));
  });
  xhr.open('GET', url);
  xhr.send();
}

$('#search').on('changeAnalyticsCustomData', function (e, args) {
  //We want to inject custom Data into each Analytics call
  args.metaObject.user = userIdToAdd.name;
  args.metaObject.role = userIdToAdd.sel;
  if (args.resultData!=undefined)
  {
    //The below values are first added as Dimensions in the Administration Console
    args.metaObject.c_istop = args.resultData.isTopResult;
    args.metaObject.c_isrecommended =  args.resultData.isRecommendation;
  }
});

expandQuery() {
  Coveo.$('.CoveoFacet').coveo('reset');
  Coveo.$('#search').coveo('state', 'hd', this.expandedComment);
  Coveo.$('#search').coveo('state', 'hq', this.expandquery);
  Coveo.$('#search').coveo('state', 'q', '');
  //If you manually trigger a query, you always must add your own Analytics event
  var customEventCause = { name: 'expand ' + this.options.name, type: 'search box' };
  Coveo.$('#search').coveo('logSearchEvent', customEventCause, {});
  Coveo.$('#search').coveo('executeQuery');
}

//***************************
//setSearchParams
//  Executed when the 'advancedsearch' is activated
//***************************
let persoFilter = "standard";
function setSearchParams() {
  let detail = '';

  let queries = {
    b1: `@mygenre=Action`,
    b2: `($qre(expression: '@mygenre=Action',modifier:'220')) ($qre(expression: '@mypeople=Willis',modifier:'220', isConstant:'true'))`,
    b3: `($qre(expression: '@mygenre=Comedy',modifier:'-200', isConstant:'true'))`,
    b4: `$weight(name:'Title', value:'0')`,
  };

  let query = queries[persoFilter] || '';
  if (query) {
    let $elem = $('#' + persoFilter).prop('checked', true);
    detail = $elem.closest('label').text();
  }
  else {
    $('#standard').prop("checked", true);
  }
  //Set the hiddenQuery parameters
  $('#search').coveo('state', 'hd', detail);
  $('#search').coveo('state', 'hq', query);
}

//On Load...

  //If the Advanced search is changed we need to trigger the change
  $('.user-personalisation-option').change(function () {
    persoFilter = $(this).attr('id');
    setSearchParams();
    //Set analytics event
    var customEventCause = {name: 'changePreferences', type:'search box'};
    $('#search').coveo('logSearchEvent', customEventCause, {});
    $('#search').coveo('executeQuery');
  });

$('#search').on('changeAnalyticsCustomData', function (e, args) {
  //Register a pageview when clicking on a result (used for Recommendations)
  // Normally this would be done by the website directly
  if (args.type === 'ClickEvent') {
    let contentType = null;
    if ((/themoviedb/).test(args.metaObject.documentURL)) {
      contentType = "Movie";
    }
    if ((/last\.fm/).test(args.metaObject.documentURL)) {
      contentType = "Music";
    }

    if (contentType) {
      let meta = args.metaObject;
      coveoua("init", Coveo.Analytics.options.token.defaultValue);
      coveoua('send', 'pageview', {
        contentIdKey: meta.contentIDKey,
        contentIdValue: meta.contentIDValue,
        contentType: contentType
      });
    }
  }
});