class API(SearchBaseHandler):
    def get_count(self, key):
        data = memcache.get(key)
        if data is not None:
            return data
        else:
            data = Ad.all().filter('published =',
                                   True).filter('modified >',
                                                datetime.datetime.now()
                                                - timedelta(days=90)).count(limit=10000)
            memcache.add(key, data, 36000)
            return data

    def get_data(self, url, key, query, number=50):
        data = memcache.get(key)
        if data is not None and len(data.results) > 0:
            return data
        else:
            data = find_documents(url, query, number, search.Cursor())
            memcache.add(key, data, 36000)
            return data

    def get_data_offset(self, url, key, query, page=1, results=20):
        data = memcache.get(key)
        if data is not None and len(data.results) > 0:
            return data
        else:
            data = find_documents_offset_api(query, results, (page-1) * results)
            memcache.add(key, data, 3600)
            return data

    def get_data_companies(self, url, key, query):
        data = memcache.get(key)
        if data is not None and len(data.results) > 0:
            return data
        else:
            data = find_documents(url, query, 50, search.Cursor())
            memcache.add(key, data, 36000)
            return data


    def get_count(self, key):
        data = memcache.get(key)
        if data is not None:
            return data
        else:
            data = Ad.all().filter('published =',
                                   True).filter('modified >',
                                                datetime.now()
                                                - timedelta(days=90)).count(limit=10000)
            memcache.add(key, data, 36000)
            return data

    def get(self):
        """Handles a get request with a query."""
        page = self.request.get('page')
        query = self.request.get('query')
        key = 'india-json-32_adlist-new' + self.request.host+page+query
        results = self.get_data_offset(self.request.host, key, query, page=int(page),results=20)
        dic = []
        import filters
        for scored_document in results:
            item = {}
            item["id"] = scored_document.fields[8].value
            item["title"] = scored_document.fields[0].value
            item["text"] = scored_document.fields[1].value
            item["img"] = filters.displayimg(scored_document.fields[8].value) #FIXME for item with no image
            dic.append(item)
        from webapp2_extras import json
        self.response.headers['Content-Type'] = 'application/json'
        self.response.write(json.encode({'results':dic}))

/api?page=1&query=java

def find_documents_offset_api(query_string, doc_limit, offsetn):
    try:
        date_desc = search.SortExpression(expression='date',
                                          direction=search.SortExpression.DESCENDING,
                                          default_value=datetime(1999, 01, 01))

        hr_desc = search.SortExpression(expression='hour',
                                        direction=search.SortExpression.DESCENDING,
                                        default_value=1)

        min_desc = search.SortExpression(expression='minute',
                                         direction=search.SortExpression.DESCENDING,
                                         default_value=1)

        # Sort up to  matching results by date in descending order
        sort = search.SortOptions(expressions=[date_desc, hr_desc,
                                               min_desc], limit=20)

        # Set query options
        options = search.QueryOptions(limit=doc_limit, offset=offsetn,
                                      sort_options=sort,
                                      number_found_accuracy=20,
                                      #  returned_fields=['title', 'city', 'region','category', 'adID', 'date','price', 'type', 'company_ad', 'adID', 'cityID','regionID', 'hour','minute'],
                                      #snippeted_fields=['text']
        )
        query = search.Query(query_string=query_string, options=options)
        index = search.Index(name=_INDEX_NAME)
        # Execute the query
        return index.search(query)

    except search.PutError as e:
        logging.exception('caught PutError %s', e)

    except search.InternalError as e:
        logging.exception('caught InternalError %s', e)

    except search.DeleteError as e:
        logging.exception('caught DeleteError %s', e)

    except search.TransientError as e:
        logging.exception('caught TransientError %s', e)

    except search.InvalidRequest as e:
        logging.exception('caught InvalidError %s', e)

    except search.Error as e:
        logging.exception('caught unknown error  %s', e)

    return None

import React, {Component} from 'react';
import {
    ActivityIndicator,
    FlatList,
    StyleSheet,
    TouchableWithoutFeedback,
    View,
    Button, AsyncStorage, Alert
} from 'react-native';
import { List, ListItem } from "react-native-elements";
import {Col, Row, Text, SearchBar } from 'react-native-elements';

class Trends extends Component {

    constructor(props) {
        super(props);

        this.state = {
            loading: false,
            data: [],
            page: 1,
            seed: 1,
            error: null,
            refreshing: false,
            text: '',
        };
        this.arrayholder = [] ;
    }

    componentDidMount() {
        this.makeRemoteRequest();
    }

    makeRemoteRequest = () => {
        const { page, seed, text } = this.state;
        const url = `https://www.koolbusiness.com/api?seed=${seed}&page=${page}&query=${text}&results=20`;
        this.setState({ loading: true });

        fetch(url)
            .then(res => res.json())
            .then(res => {

                this.setState({
                    data: page === 1 ? res.results : [...this.state.data, ...res.results],
                    error: res.error || null,
                    loading: false,

                    refreshing: false
                }, function() {

                });
            })
            .catch(error => {
                this.setState({ error, loading: false });
            });
    };
    handleRefresh = () => {
        this.setState(
            {
                page: 1,
                seed: this.state.seed + 1,
                refreshing: true
            },
            () => {
                this.makeRemoteRequest();
            }
        );
    };

    handleLoadMore = () => {
        this.setState(
            {
                page: this.state.page + 1
            },
            () => {
                this.makeRemoteRequest();
            }
        );
    };

    renderSeparator = () => {
        return (
            <View
                style={{
                    height: 1,
                    width: "86%",
                    backgroundColor: "#CED0CE",
                    marginLeft: "14%"
                }}
            />
        );
    };
    SearchFilterFunction(text){
        this.setState({
            data: [],
            text: text
        });
        this.handleRefresh();
    }
    renderHeader = () => {
        return <SearchBar  onChangeText={(text) => this.SearchFilterFunction(text)}
                             placeholder="Type Here..." lightTheme round />;
    };
    renderFooter = () => {
        if (!this.state.loading) return null;
        return (
            <View
                style={{
                    paddingVertical: 20,
                    borderTopWidth: 1,
                    borderColor: "#CED0CE"
                }}
            >
                <ActivityIndicator animating size="large" />
            </View>
        );
    };
    render() {
        return (
            <List containerStyle={{ borderTopWidth: 0, borderBottomWidth: 0 }}>
                <FlatList
                    data={this.state.data}
                    renderItem={({ item }) => (
                        <TouchableWithoutFeedback onPress={() => this.props.navigation.navigate('Details', { id: item.id })} >

                        <ListItem
                            roundAvatar
                            title={`${item.title}`}
                            subtitle={item.text}
                            avatar={{ uri: item.img }}
                            containerStyle={{ borderBottomWidth: 0 }}
                        />
                        </TouchableWithoutFeedback>
                    )}
                    keyExtractor={item => item.id}
                    ItemSeparatorComponent={this.renderSeparator}
                    ListHeaderComponent={this.renderHeader}
                    ListFooterComponent={this.renderFooter}
                    onRefresh={this.handleRefresh}
                    refreshing={this.state.refreshing}
                    onEndReached={this.handleLoadMore}
                    onEndReachedThreshold={50}
                />
            </List>
        );
    }
}

const styles = StyleSheet.create({
    listHeader: {
        flex: 1,
        flexDirection: "row",
        marginLeft: 10,
        marginTop: 5,
    },
    container: {
        flex: 1,
    },
    headerContainer: {
        justifyContent: 'center',
        alignItems: 'center',
        padding: 40,
        backgroundColor: '#FD6B78'
    },
    heading: {
        color: 'white',
        marginTop: 10,
        fontSize: 22,
    },
    text: {
        marginLeft: 20,
        flex: 1
    },
    image: {
        marginRight: 20,
        width: 30,
        height: 30,
        flex: 3,
    }
});

export default Trends;