import express from 'express'
import bodyParser from 'body-parser';
import distanceInWordsToNow from 'date-fns/distance_in_words_to_now';
import parseDate from 'date-fns/format';
import moment from 'moment';

import {
  STATUS_NORMAL,
  STATUS_RESERVED,
  STATUS_SOLD
} from "./enums";

var hr = require('date-fns/locale/hr');

var MongoClient = require('mongodb').MongoClient;
var ObjectID = require('mongodb').ObjectID;

var url = 'mongodb://localhost:27017/kivi';

require("babel-polyfill");

const router = express.Router({mergeParams: true})

const PORT = process.env.PORT || 3001;
const AGENTURA_KEY = process.env.AGENTURA_KEY || '1somethingverysecret';

let db;

router.post('/contact/:listingId', async (req, res, next) => {

  try {
    const listingId = req.params.listingId;
    const body = req.body;

    const contactRequests = db.collection('contact_requests');

    if (!body.email) {
      res.status(422);
      res.end('Email is required');
      return
    }

    if (!body.name) {
      res.status(422);
      res.end('Name is required');
      return
    }

    const result = await contactRequests.insertOne({
      name    : body.name,
      email   : body.email,
      listingId,
      message : body.message,
      phone   : body.phone,
      alert   : body.alert
    });

    res.status(200);
    res.end();
  } catch (e) {
    console.log('error:', e);
    next(e);
  }
});

router.get('/search/listings/:id', async (req, res, next) => {
  try {
    const id = req.params.id;

    const listings = db.collection('listings');
    const listing = await listings.findOne({_id: new ObjectID(id)});
    if (listing) {
      res.json(listing);
    } else {
      res.status(404);
    }

    res.end();
  } catch (e) {
    console.log('error:', e);
    next(e);
  }
});

router.get('/search/listings', async (req, res, next) => {
  try {
    console.log("Search listings");
    const bounds       = req.query.bounds || '';
    const minPrice     = req.query.minPrice;
    const maxPrice     = req.query.maxPrice;
    const minSize      = req.query.minSize;
    const maxSize      = req.query.maxSize;
    const rooms        = req.query.rooms;
    const adType       = req.query.adType;
    const category     = req.query.category;
    const sort         = req.query.sort;
    const page         = req.query.page || 0;
    const pins         = req.query.pins || false;

    const properties = db.collection('listings');
    let query        = {};


    //Get only ads with location
    query = Object.assign(query, {
      has_map: true
    });

    //AND

    //Do not show sold or reserved properity
    query = Object.assign(query, {
      status: STATUS_NORMAL
    });

    //AND

    //Show ads that fall inside visible map
    if (bounds) {
      const [lat1, lng1, lat2, lng2] = bounds.split(',').map(parseFloat)
      const box                      = [[lat1, lng1], [lat2, lng2]];

      query = Object.assign(query, {
        loc: {
          "$geoWithin": {
            "$box": box
          }
        }
      });
    }

    //AND

    //Show only selected type of ads (selling or renting)
    if (adType) {
      query = Object.assign(query, {
        adType: parseInt(adType)
      });
    }

    //AND

    //Match price
    if (minPrice || maxPrice) {
      const price = {}
      if (minPrice) {
        price["$gte"] = parseFloat(minPrice);
      }

      if (maxPrice) {
        price["$lte"] = parseFloat(maxPrice);
      }

      query = Object.assign(query, {
        price
      });
    }

    //AND

    //Match number of rooms
    if (rooms) {
      const room_count = [];
      let four_plus = false;

      const allRooms = rooms.split(',');
      allRooms.map((val)=>{
        if (parseInt(val)!==4){
          room_count.push(parseInt(val));
        }else{
          four_plus=true;
        }
      });

      if (four_plus){
        query = Object.assign(query,{
          rooms: {'$gte' : 4}
        });
      }else{
        query = Object.assign(query,{
          rooms: {'$in' : room_count}
        });
      }
    }

    //AND


    //Match size
    if (minSize || maxSize) {
      const size = {}
      if (minSize) {
        size["$gte"] = parseFloat(minSize);
      }

      if (maxSize) {
        size["$lte"] = parseFloat(maxSize);
      }

      query = Object.assign(query, {
        size
      });
    }

    //AND

    //Match category
    if (category) {
      const category_count = [];

      const allCategories = category.split(',').map(val => {
          category_count.push(parseInt(val));
      });

      query = Object.assign(query, {
        category: {'$in' : category_count}
      });

      
    }

    console.log('QUERY: ', query);
    const cnt = await properties.find(query).count();

    res.header('X-Total-Count', cnt);

    const getSort = () => {
      if (sort === 'price-min') {
        return [['price', 'asc']];
      } else if (sort === 'price-max') {
        return [['price', 'desc']];
      } else if (sort === 'newest') {
        return [['_id', 'desc']];
      } else if (sort === 'relevance') {
        // TODO: figure out what the relevance is
        return [];
      }
    };

    let all = properties.find(query, {
      //"sort": [['field1','asc'], ['field2','desc']]
      "sort": getSort()
    });

    const isPins = pins === "true";

    if (!isPins) {
      all = await all.skip(20 * page).limit(20).toArray();
    } else {
      all = await all.toArray();
    }

    if (all.length > 0) {
      res.header('X-Last-Record-Id', [...all].pop()._id);
    }

    if (isPins) {
      res.json(all.map(val => {
        return {
          _id: val._id,
          loc: val.loc
        }
      }));
    } else {

      res.json(all.map(({_id,
                       address,
                       images,
                       price,
                       rooms,
                       size,
                       time
      }) => ({
        _id,
        address,
        images: [images[0]],
        price,
        rooms,
        size,
        time: distanceInWordsToNow(
        moment(time, 'DD.MM.YYYY'),
        {locale: hr}
      ),
        realTime: time
      })));
    }

    res.end();
  } catch (e) {
    console.log('error:', e);
    next(e);
  }
});


const app = express()
app.use(bodyParser.json());

app.use(function(req, res, next) {
  res.header("Access-Control-Allow-Origin", "*");
  res.header("Access-Control-Allow-Headers", "Origin, X-Requested-With, Content-Type, Accept, X-Last-Record-Id, X-Total-Count");
  res.header("Access-Control-Expose-Headers", "X-Last-Record-Id, X-Total-Count");
  res.header("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
  res.header('Access-Control-Allow-Credentials', 'true');
  next();
});

app.use('/api', router);

MongoClient.connect(url).then((database) => {
  db = database;
  db.collection('listings').createIndex({loc: "2d"});
  app.listen(PORT, () => console.log('Express server running at localhost: ' + PORT));
});