import json

from functools import partial

import jsonschema

from flask import Blueprint, abort, current_app, jsonify, request

from pkg_resources import resource_filename

from .auth import httpauth

from .utils import ActiveStatus, ActiveStatusv14, first, fuzzy_list_find

sensors_views = Blueprint("sensors", __name__)

ALLOWED_SENSORS_KEYS = json.load(

    open(resource_filename("spaceapi", "schema/sensors.json"), encoding="utf-8")

)

RADIATON_SUBKEYS = frozenset(("alpha", "beta", "gamma", "beta_gamma"))

get_identification_key = partial(first, keys=frozenset(("name", "location")))

def set_value(data, key):

    try:

        subkey = get_identification_key(data)

    except ValueError:

        current_app.logger.error("Subkey Error")

        return abort(400)

    try:

        index = fuzzy_list_find(active["sensors"][key], subkey, data[subkey])

        if key == "barometer":

        active["sensors"][key][index].update(data)

    except ValueError:

        active["sensors"][key].append(data)

    active.save_last_state()

    return jsonify(active)

def set_radiation_value(data):

    radiation_keys = [k for k in RADIATON_SUBKEYS if k in data]

    if not radiation_keys:

        return abort(400)

    for first_subkey in radiation_keys:

        try:

            second_subkey = get_identification_key(data[first_subkey])

        except ValueError:

            return abort(400)

        try:

            index = fuzzy_list_find(

                active["sensors"]["radiation"][first_subkey],

                second_subkey,

                data[first_subkey][second_subkey],

            )

            active["sensors"]["radiation"][first_subkey][index].update(data)

        except ValueError:

            active["sensors"]["radiaton"][first_subkey].append(data)

    active.save_last_state()

    return jsonify(active)

@sensors_views.route("/set/<key>", methods=["POST"])

@httpauth.login_required

def set_sensors(key):

    if key in ALLOWED_SENSORS_KEYS and key in active["sensors"]:

        data = request.json

        try:

            try:

                jsonschema.validate(data, ALLOWED_SENSORS_KEYS[key])

            except jsonschema.ValidationError:

                current_app.logger.error("Validation Error")

                return abort(400)

            if key != "radiation":

                return set_value(data, key)

            else:

                return set_radiation_value(data)

        except ValueError:

            current_app.logger.error("Value Error")

            return abort(400)

    else:

        current_app.logger.error("Sensor not allowed")

        return abort(400)

import json

import os.path

import random

from functools import wraps

from time import time

import mastodon

import tweepy

from flask import current_app, request

default_json_file = os.path.abspath("default.json")

last_state_file = os.path.abspath("laststate.json")

default_json_file_v14 = os.path.abspath("default_v14.json")

last_state_file_v14 = os.path.abspath("laststate_v14.json")

if not os.path.exists(default_json_file):

    raise RuntimeError("default.json does not exists!")

elif not os.path.isfile(default_json_file):

    raise RuntimeError("default.json is not a file!")

if not os.path.exists(default_json_file_v14):

    raise RuntimeError("default_v14.json does not exists!")

elif not os.path.isfile(default_json_file):

    raise RuntimeError("default_v14.json is not a file!")

possible_open_tweets = (

    "The space is now open!",

    "The space is open! Come in and hack something!",

    "Yes, we're open! Come in and create something!",

    "Come by and hack something! We've just opened!",

    "The ChaosStuff is now open for everyone!",

    "Let the Chaos begin! We're open!",

    "What do we hack now? Come and see, we've just opened!",

    "TUWAT! Come and hack. We are open!",

)

possible_closed_tweets = (

    "The space is now closed!",

    "We're closed now! See you soon.",

    "Sorry, we are closed now!",

    "The ChaosStuff is now closed! Come back another time!",

    "Poweroff process finished! We're closed!",

    "Singularity reached! The space is closed!",

    "Dream of electric sheeps! We are closed!",

)

def post_tweet(tweet, spaceapi=None):

    if "TWITTER_CONSUMER_KEY" in current_app.config:

        auth = tweepy.OAuthHandler(

            current_app.config["TWITTER_CONSUMER_KEY"],

            current_app.config["TWITTER_CONSUMER_SECRET"],

        )

        auth.set_access_token(

            current_app.config["TWITTER_ACCESS_TOKEN_KEY"],

            current_app.config["TWITTER_ACCESS_TOKEN_SECRET"],

        )

        api = tweepy.API(auth)

        if spaceapi is None:

            api.update_status(tweet)

        else:

            api.update_status(

                tweet, lat=spaceapi["location"]["lat"], lon=spaceapi["location"]["lon"]

            )

def post_toot(toot):

    if "MASTODON_USERCRED_FILE" in current_app.config:

        api = mastodon.Mastodon(

            client_id="c3l_spaceapi_clientcred.secret",

            access_token=current_app.config["MASTODON_USERCRED_FILE"],

            api_base_url="https://chaos.social",

        )

        api.status_post(toot, visibility="unlisted")

class Singleton:

    def __new__(cls, *args, **kwargs):

        key = str(hash(cls))

        if not hasattr(cls, "_instance_dict"):

            cls._instance_dict = {}

        if key not in cls._instance_dict:

            cls._instance_dict[key] = super().__new__(cls, *args, **kwargs)

        return cls._instance_dict[key]

class ActiveStatus(Singleton, dict):

    def __init__(self):

        self.default_json_file = default_json_file

        self.last_state_file = last_state_file

    def reload(self):

        with open(self.default_json_file, encoding="utf-8") as f:

            self.update(json.load(f))

        if os.path.exists(self.last_state_file) and os.path.isfile(

            self.last_state_file

        ):

            with open(self.last_state_file, encoding="utf-8") as f:

                last_state_json = json.load(f)

            self["state"] = last_state_json["state"]

            self["sensors"].update(last_state_json["sensors"])

    def save_last_state(self):

        with open(self.last_state_file, mode="w", encoding="utf-8") as f:

            last_state = {}

            last_state["state"] = self["state"]

            last_state["sensors"] = self["sensors"]

            json.dump(last_state, f, sort_keys=True)

    def add_user_present(self, username):

        if self["state"]["open"]:

            if "people_now_present" not in self["sensors"]:

                self["sensors"]["people_now_present"] = [{"value": 0}]

            people_now_present = self["sensors"]["people_now_present"][0]

            if (

                "names" in people_now_present

                and username not in people_now_present["names"]

            ):

                people_now_present["value"] += 1

                if username in current_app.config["PEOPLE_NOW_PRESENT_ALLOWED"]:

                    people_now_present["names"].append(username)

            elif "names" not in people_now_present:

                people_now_present["value"] += 1

                if username in current_app.config["PEOPLE_NOW_PRESENT_ALLOWED"]:

                    people_now_present["names"] = [username]

            self["sensors"]["people_now_present"][0] = people_now_present

        else:

            pass

    def remove_user_present(self, username):

        if self["state"]["open"] and "people_now_present" in self["sensors"]:

            people_now_present = self["sensors"]["people_now_present"][0]

            if people_now_present["value"] > 0:

                people_now_present["value"] -= 1

            if "names" in people_now_present:

                if username in people_now_present["names"]:

                    people_now_present["names"].remove(username)

                if not people_now_present["names"] or people_now_present["value"] == 0:

                    del people_now_present["names"]

            self["sensors"]["people_now_present"][0] = people_now_present

        else:

            pass

    def clear_user_present(self):

        self["sensors"]["people_now_present"][0]["value"] = 0

        if "names" in self["sensors"]["people_now_present"][0]:

            del self["sensors"]["people_now_present"][0]["names"]

    def send_tweet(self, value):

        tweet = (

            random.choice(possible_open_tweets)

            if value

            else random.choice(possible_closed_tweets)

        )

        try:

            post_tweet(tweet, self)

        except Exception as e:

            current_app.logger.error("Sending tweet failed! %s" % e, exc_info=True)

        try:

            post_toot(tweet)

        except Exception as e:

            current_app.logger.error("Sending toot failed! %s" % e, exc_info=True)

    def set_new_state(self, value=None, trigger_person=None, message=None):

        if value is not None and value != self["state"]["open"]:

            self["state"]["open"] = value

            self.send_tweet(value)

            if not value:

                if "people_now_present" in self["sensors"]:

                    self.clear_user_present()

                if "message" in self["state"]:

                    del self["state"]["message"]

            if trigger_person is None:

                if "trigger_person" in self["state"]:

                    del self["state"]["trigger_person"]

            else:

                self["state"]["trigger_person"] = trigger_person

            self["state"]["lastchange"] = int(time())

        if message is not None and message:

            self["state"]["message"] = message

class ActiveStatusv14(ActiveStatus):

    def __init__(self):

        self.default_json_file = default_json_file_v14

        self.last_state_file = last_state_file_v14

def request_wants_json():

    best = request.accept_mimetypes.best_match(["application/json", "text/html"])

    return (

        best == "application/json"

        and request.accept_mimetypes[best] > request.accept_mimetypes["text/html"]

    )

def fuzzy_list_find(lst, key, value):

    for i, dic in enumerate(lst):

        if dic[key] == value:

            return i

    raise ValueError

def first(iterable, keys):

    for key in keys:

        if key in iterable:

            return key

    raise ValueError

def pass_active_status(f):

    @wraps(f)

    def wrapper(*args, **kwargs):

        rv = f(status, *args, **kwargs)

        status.save_last_state()

        return rv

    return wrapper

from flask import (

    Blueprint,

    abort,

    current_app,

    jsonify,

    redirect,

    render_template,

    request,

    url_for,

)

from .auth import basicauth, httpauth

from .utils import ActiveStatus, ActiveStatusv14, request_wants_json

root_views = Blueprint("root", __name__)

@root_views.route("/")

def index():

    if request_wants_json():

    return render_template("index.html", status=ActiveStatus())

@root_views.route("/status.json")

def status_json():

    return jsonify(ActiveStatusv14())

@root_views.route("/reload")

@httpauth.login_required

def reload():

    active = ActiveStatusv14()

    active.reload()

    return jsonify(active)

@root_views.route("/open", methods=("GET", "POST"))

@httpauth.login_required

def open():

    if request.method == "POST":

        try:

            if (

                httpauth.username()

                in current_app.config["STATE_TRIGGER_PERSON_ALLOWED"]

            ):

                trigger_person = httpauth.username()

            else:

                trigger_person = None

        except KeyError:

            trigger_person = None

        if "close" in request.form:

            new_state = False

        elif "open" in request.form:

            new_state = True

        if "message" in request.form:

            message = request.form.get("message")

        else:

            message = None

        active.set_new_state(

            value=new_state, trigger_person=trigger_person, message=message

        )

        active.save_last_state()

        return redirect(url_for("root.index"))

    return render_template("open.html")

@root_views.route("/present", methods=("GET", "POST"))

@httpauth.login_required

def present():

    if request.method == "POST":

        if active["state"]["open"]:

            user = (

                httpauth.username()

                if "user" not in request.form

                else request.form["user"]

            )

            if "present" in request.form:

                active.add_user_present(user)

            elif "leave" in request.form:

                active.remove_user_present(user)

            else:

                return redirect(url_for("root.index"))

            active.save_last_state()

        return redirect(url_for("root.index"))

    return render_template("present.html")

@root_views.route("/basicopen", methods=("GET", "POST"))

@basicauth.login_required

def basicopen():

    if request.method == "POST":

        try:

            if (

                httpauth.username()

                in current_app.config["STATE_TRIGGER_PERSON_ALLOWED"]

            ):

                trigger_person = httpauth.username()

            else:

                trigger_person = None

        except KeyError:

            trigger_person = None

        if "close" in request.form:

            new_state = False

        elif "open" in request.form:

            new_state = True

        if "message" in request.form:

            message = request.form.get("message")

        else:

            message = None

        active.set_new_state(

            value=new_state, trigger_person=trigger_person, message=message

        )

        active.save_last_state()

        return redirect(url_for("root.index"))

    return render_template("open.html")

@root_views.route("/basicpresent", methods=("GET", "POST"))

@basicauth.login_required

def basicpresent():

    if request.method == "POST":

        if active["state"]["open"]:

            user = (

                httpauth.username()

                if "user" not in request.form

                else request.form["user"]

            )

            if "present" in request.form:

                active.add_user_present(user)

            elif "leave" in request.form:

                active.remove_user_present(user)

            else:

                return redirect(url_for("root.index"))

            active.save_last_state()

        return redirect(url_for("root.index"))

    return render_template("present.html")