moneropro/app/charts/views.py

from django.shortcuts import render
from django.http import HttpResponseRedirect
from django.urls import reverse
from django.conf import settings
import json
from .models import (
    Coin,
    DailyData,
    Dominance,
    P2Pool,
    Rank,
    Sfmodel,
    Social,
    Withdrawal,
)
from .forms import CoinForm
import datetime
from datetime import date, timedelta
import math
import locale
import pandas as pd
from . import asynchronous
from . import synchronous
from operator import truediv
from django.contrib.auth.decorators import login_required
from django.contrib.staticfiles.storage import staticfiles_storage
from charts.synchronous import get_history_function

# TODO: Split this into multiple files

####################################################################################
#   Set some parameters
####################################################################################
locale.setlocale(locale.LC_ALL, "en_US.utf8")  # TODO: Why is this here?
DATA_FILE = settings.DATA_FILE

try:
    locale.format
except AttributeError:
    locale.format = locale.format_string

####################################################################################
#   Useful functions for admins
####################################################################################


# Add manually a new entrance for coin
# To be used when there's a problem with the API
@login_required
def add_coin(request):
    if not request.user.is_superuser:
        return render(request, "users/error.html")

    if request.method != "POST":
        # create new page with blank form
        form = CoinForm()
    else:
        # process data and submit article
        form = CoinForm(data=request.POST)
        if form.is_valid():
            add_coin = form.save(commit=False)
            coin = Coin.objects.filter(name=add_coin.name).filter(date=add_coin.date)
            if coin:
                for item in coin:
                    item.delete()
                print("coin found and deleted")
            else:
                print("coin not found")

            add_coin.stocktoflow = (100 / add_coin.inflation) ** 1.65
            print(add_coin.name)
            print(add_coin.date)
            print(add_coin.priceusd)
            print(add_coin.pricebtc)
            print(add_coin.inflation)
            print(add_coin.transactions)
            print(add_coin.hashrate)
            print(add_coin.stocktoflow)
            print(add_coin.supply)
            print(add_coin.fee)
            print(add_coin.revenue)
            print(add_coin.blocksize)
            print(add_coin.difficulty)
            add_coin.save()
            print("coin saved")
            message = "Coin added to the database!"
            coin = Coin.objects.filter(name=add_coin.name).get(date=add_coin.date)
            print(
                "GET: "
                + str(coin.name)
                + " "
                + str(coin.date)
                + " "
                + str(coin.priceusd)
                + " "
                + str(coin.pricebtc)
                + " "
                + str(coin.inflation)
                + " "
                + str(coin.transactions)
                + " "
                + str(coin.hashrate)
                + " "
                + str(coin.stocktoflow)
                + " "
                + str(coin.supply)
                + " "
                + " "
                + str(coin.fee)
                + " "
                + " "
                + str(coin.revenue)
            )

            print("updating p2pool")
            synchronous.update_p2pool()

            context = {"form": form, "message": message}
            return render(request, "charts/add_coin.html", context)
        else:
            message = "An error has happened. Try again."
            context = {"form": form, "message": message}
            return render(request, "charts/add_coin.html", context)

    context = {"form": form}
    return render(request, "charts/add_coin.html", context)


# Get all history for metrics of a certain coin named as 'symbol'
# Only authorized users can download all price data via URL request
@login_required
def get_history(request, symbol, start_time=None, end_time=None):
    if not request.user.is_superuser:
        return render(request, "users/error.html")

    count = get_history_function(symbol, start_time, end_time)

    if type(count) in [int, "int"]:
        message = "Total of " + str(count) + " data imported"
        context = {"message": message}
    else:
        message = "Failed to load the data"
        context = {"message": message}

    return render(request, "charts/maintenance.html", context)


# Populate database with rank history
# Only authorized users can do this
@login_required
def load_rank(request, symbol):
    if not request.user.is_superuser:
        return render(request, "users/error.html")

    df = pd.read_excel(DATA_FILE, sheet_name="Sheet8", engine="odf")
    start_row, end_row = 2, 9999
    start_col, end_col = 0, 2
    values_mat = df.iloc[start_row:end_row, start_col:end_col].to_numpy()

    count = 0
    print(len(values_mat))
    Rank.objects.all().delete()

    for k in range(0, len(values_mat)):
        if values_mat[k][0] and values_mat[k][1]:
            rank = Rank()
            rank.name = symbol
            rank.date = values_mat[k][0]
            rank.rank = int(values_mat[k][1].replace(",", "."))
            if not (rank.rank) and not (rank.date):
                break
            else:
                rank.save()
                count += 1
        else:
            break

    message = "Total of " + str(count) + " data imported"
    context = {"message": message}
    return render(request, "charts/maintenance.html", context)


# Populate database with p2pool history
# Only authorized users can do this
@login_required
def load_p2pool(request):
    if not request.user.is_superuser:
        return render(request, "users/error.html")

    count = 0

    df = pd.read_excel(DATA_FILE, sheet_name="p2pool", engine="odf")
    start_row, end_row = 2, 9999
    start_col, end_col = 0, 6
    values_mat = df.iloc[start_row:end_row, start_col:end_col].to_numpy()

    P2Pool.objects.all().delete()

    for k in range(0, len(values_mat)):
        if values_mat[k][0] and values_mat[k][1]:
            p2pool_stat = P2Pool()
            p2pool_stat.date = values_mat[k][0]

            p2pool_stat.miners = (
                float(values_mat[k][1].replace(",", "."))
                if isinstance(values_mat[k][1], str)
                else values_mat[k][1]
            )
            p2pool_stat.hashrate = (
                float(values_mat[k][2].replace(",", "."))
                if isinstance(values_mat[k][2], str)
                else values_mat[k][2]
            )
            p2pool_stat.percentage = (
                float(values_mat[k][3].replace(",", "."))
                if isinstance(values_mat[k][3], str)
                else values_mat[k][3]
            )
            p2pool_stat.totalhashes = (
                float(values_mat[k][4].replace(",", "."))
                if isinstance(values_mat[k][4], str)
                else values_mat[k][4]
            )
            p2pool_stat.totalblocksfound = (
                float(values_mat[k][5].replace(",", "."))
                if isinstance(values_mat[k][5], str)
                else values_mat[k][1]
            )
            p2pool_stat.mini = False
            p2pool_stat.save()
            count += 1
            # print('p2poolmini data saved - ' + str(p2pool_stat.date) + ' - ' + str(p2pool_stat.percentage) + ' - ' + str(p2pool_stat.miners))
        else:
            break

    df = pd.read_excel(DATA_FILE, sheet_name="p2poolmini", engine="odf")
    start_row, end_row = 2, 9999
    start_col, end_col = 0, 6
    values_mat = df.iloc[start_row:end_row, start_col:end_col].to_numpy()

    for k in range(0, len(values_mat)):
        if values_mat[k][0] and values_mat[k][1]:
            p2pool_stat = P2Pool()
            p2pool_stat.date = values_mat[k][0]
            p2pool_stat.miners = (
                float(values_mat[k][1].replace(",", "."))
                if isinstance(values_mat[k][1], str)
                else values_mat[k][1]
            )
            p2pool_stat.hashrate = (
                float(values_mat[k][2].replace(",", "."))
                if isinstance(values_mat[k][2], str)
                else values_mat[k][2]
            )
            p2pool_stat.percentage = (
                float(values_mat[k][3].replace(",", "."))
                if isinstance(values_mat[k][3], str)
                else values_mat[k][3]
            )
            p2pool_stat.totalhashes = (
                float(values_mat[k][4].replace(",", "."))
                if isinstance(values_mat[k][4], str)
                else values_mat[k][4]
            )
            p2pool_stat.totalblocksfound = (
                float(values_mat[k][5].replace(",", "."))
                if isinstance(values_mat[k][5], str)
                else values_mat[k][5]
            )
            p2pool_stat.mini = True
            p2pool_stat.save()
            count += 1
            # print('p2poolmini data saved - ' + str(p2pool_stat.date) + ' - ' + str(p2pool_stat.percentage) + ' - ' + str(p2pool_stat.miners))
        else:
            break

    message = "Total of " + str(count) + " data imported"
    context = {"message": message}
    return render(request, "charts/maintenance.html", context)


# Populate database with dominance history
# Only authorized users can do this
@login_required
def load_dominance(request, symbol):
    if not request.user.is_superuser:
        return render(request, "users/error.html")

    df = pd.read_excel(DATA_FILE, sheet_name="Sheet7", engine="odf")
    start_row, end_row = 2, 9999
    start_col, end_col = 0, 2
    values_mat = df.iloc[start_row:end_row, start_col:end_col].to_numpy()

    count = 0
    Dominance.objects.all().delete()

    for k in range(0, len(values_mat)):
        if values_mat[k][0] and values_mat[k][1]:
            dominance = Dominance()
            dominance.name = symbol
            dominance.date = values_mat[k][0]
            dominance.dominance = (
                float(values_mat[k][1].replace(",", "."))
                if isinstance(values_mat[k][1], str)
                else values_mat[k][1]
            )
            if not (dominance.dominance) and not (dominance.date):
                break
            else:
                dominance.save()
                count += 1
        else:
            break

    message = "Total of " + str(count) + " data imported"
    context = {"message": message}
    return render(request, "charts/maintenance.html", context)


# Import Reddit history from file on static folder
# Only authorized users can do this
@login_required
def importer(request):
    if not request.user.is_superuser:
        return render(request, "users/error.html")
    count = 0
    Social.objects.all().delete()
    filename = staticfiles_storage.path("import.txt")
    with open(filename) as f:
        content = f.readlines()
        for line in content:
            data = json.loads(line)
            symbol = data["name"]
            item = data["subscriberCountTimeSeries"]
            dates = []
            subscriberCount = []
            commentsPerHour = []
            postsPerHour = []
            for unit in item:
                date_now = datetime.datetime.strptime("1970-01-01", "%Y-%m-%d")
                date_now += timedelta(int(unit["utcDay"]))
                dates.append(datetime.datetime.strftime(date_now, "%Y-%m-%d"))
                value = float(unit["count"])
                subscriberCount.append(value)
            item = data["commentsPerHourTimeSeries"]
            for unit in item:
                value = float(unit["commentsPerHour"])
                commentsPerHour.append(value)
            item = data["postsPerHourTimeSeries"]
            for unit in item:
                value = float(unit["postsPerHour"])
                postsPerHour.append(value)

            for i in range(len(dates) - 1):
                social = Social()
                social.name = symbol
                social.date = dates[i]
                if i >= len(dates) - len(subscriberCount):
                    social.subscriberCount = subscriberCount[i - len(subscriberCount)]
                else:
                    social.subscriberCount = 0
                if i >= len(dates) - len(commentsPerHour):
                    social.commentsPerHour = commentsPerHour[
                        i - (len(dates) - len(commentsPerHour))
                    ]
                else:
                    social.commentsPerHour = 0
                if i >= len(dates) - len(postsPerHour):
                    social.postsPerHour = postsPerHour[
                        i - (len(dates) - len(postsPerHour))
                    ]
                else:
                    social.postsPerHour = 0
                social.save()
                count += 1

    message = "Total of " + str(count) + " data imported"
    context = {"message": message}
    return render(request, "charts/maintenance.html", context)


# Erase all data for a certain coin
# Only authorized users can do this
@login_required
def reset(request, symbol):
    if not request.user.is_superuser:
        return render(request, "users/error.html")
    Coin.objects.filter(name=symbol).all().delete()

    message = "All data for " + str(symbol) + " erased"
    context = {"message": message}
    return render(request, "charts/maintenance.html", context)


# Populate database with especific chart variables
# Only authorized users can do this
@login_required
def populate_database(request):
    if not request.user.is_superuser:
        return render(request, "users/error.html")
    count = 0

    ###################################################################
    # SF model charts
    ###################################################################
    print(
        "Populating database for sfmodel.html, sfmodelin.html and pricesats.html, wait a moment..."
    )
    Sfmodel.objects.all().delete()
    timevar = 1283
    v0 = 0.002
    delta = (0.015 - 0.002) / (6 * 365)
    previous_supply = 0
    supply = 0
    sf_aux = 0
    count_aux = 0

    coins = Coin.objects.order_by("date").filter(name="xmr")
    for coin in coins:
        if coin.priceusd < 0.1:
            coin.priceusd = 0.1
            coin.pricebtc = 0.000001
        if coin.stocktoflow > sf_aux * 1.3 + 100:
            coin.stocktoflow = sf_aux

        sf_aux = coin.stocktoflow
        if coin.supply > 0:
            supply = int(coin.supply) * 10**12
        else:
            supply = previous_supply
        count += 1
        count_aux += 1

        data = Sfmodel()
        data.date = coin.date
        data.priceusd = coin.priceusd
        data.pricebtc = coin.pricebtc
        data.stocktoflow = coin.stocktoflow
        data.color = 30 * coin.pricebtc / (count * delta + v0)
        date_aux1 = datetime.datetime.strptime("2017-12-29", "%Y-%m-%d")
        date_aux2 = datetime.datetime.strftime(coin.date, "%Y-%m-%d")
        date_aux2 = datetime.datetime.strptime(date_aux2, "%Y-%m-%d")
        if date_aux2 < date_aux1:
            lastprice = coin.priceusd
            current_inflation = coin.inflation
            data.greyline = 0
            count_aux = 0
        else:
            day = date_aux2 - timedelta(timevar)
            coin_aux1 = Coin.objects.filter(name="xmr").get(date=day)
            day = date_aux2 - timedelta(timevar + 1)
            coin_aux2 = Coin.objects.filter(name="xmr").get(date=day)
            date_aux3 = datetime.datetime.strptime("2017-12-29", "%Y-%m-%d")

            if date_aux3 + timedelta(int(count_aux * 2)) < datetime.datetime.strptime(
                "2021-07-03", "%Y-%m-%d"
            ):
                day = date_aux3 + timedelta(int(count_aux * 2))
                coin_aux3 = Coin.objects.filter(name="xmr").get(date=day)
                if coin_aux3:
                    if (coin_aux3.inflation / current_inflation) > 1.2 or (
                        coin_aux3.inflation / current_inflation
                    ) < 0.8:
                        coin_aux3.inflation = current_inflation
                    else:
                        current_inflation = coin_aux3.inflation
                supply2 = supply
            else:
                reward2 = (2**64 - 1 - supply2) >> 19
                if reward2 < 0.6 * (10**12):
                    reward2 = 0.6 * (10**12)
                supply2 += int(720 * reward2)
                current_inflation = 100 * reward2 * 720 * 365 / supply2

            if coin_aux1 and coin_aux2:
                lastprice += (coin_aux1.priceusd / coin_aux2.priceusd - 1) * lastprice
                actualprice = lastprice * (
                    math.sqrt(coin.inflation / current_inflation)
                )
                data.greyline = actualprice
            else:
                data.greyline = 0
            previous_supply = supply
        data.save()

    count_aux = 0
    for count_aux in range(700):
        date_now = date.today() + timedelta(count_aux)
        reward = (2**64 - 1 - supply) >> 19
        if reward < 0.6 * (10**12):
            reward = 0.6 * (10**12)
        supply += int(720 * reward)

        data = Sfmodel()
        data.date = datetime.datetime.strftime(date_now, "%Y-%m-%d")
        data.stocktoflow = (100 / (100 * reward * 720 * 365 / supply)) ** 1.65
        data.priceusd = 0
        data.pricebtc = 0
        data.greyline = 0
        data.color = 0
        data.priceusd = 0
        data.greyline = 0
        data.save()
        count += 1

    ###################################################################
    # Daily Emissions, inflation charts and coins against bitcoin
    ###################################################################
    print(
        "Populating database for dailyemission.html and dailyemissionntv.html, wait a moment..."
    )
    DailyData.objects.all().delete()
    supply_btc = 0
    supply_xmr = 0
    count_aux = 0
    coins_btc = Coin.objects.order_by("date").filter(name="btc")

    for coin_btc in coins_btc:
        count_aux += 1
        data = DailyData()
        data.date = datetime.datetime.strftime(coin_btc.date, "%Y-%m-%d")

        if coin_btc.blocksize > 0:
            data.btc_blocksize = coin_btc.blocksize
            data.btc_transactions = coin_btc.transactions
        else:
            data.btc_blocksize = 0
            data.btc_transactions = 0

        if coin_btc.difficulty > 0:
            data.btc_difficulty = coin_btc.difficulty
        else:
            data.btc_difficulty = 0

        if coin_btc.transactions == 0:
            data.btc_transcostusd = 0
            data.btc_transcostntv = 0
        else:
            if coin_btc.fee * coin_btc.priceusd / coin_btc.transactions < 0.0001:
                data.btc_transcostusd = 0
                data.btc_transcostntv = 0
            else:
                data.btc_transcostusd = (
                    coin_btc.fee * coin_btc.priceusd / coin_btc.transactions
                )
                data.btc_transcostntv = coin_btc.fee / coin_btc.transactions

        if coin_btc.revenue < 0.000001 or coin_btc.priceusd < 0.001:
            data.btc_minerrevntv = 0
            data.btc_minerrevusd = 0
            data.btc_commitntv = 0
            data.btc_commitusd = 0
            data.btc_priceusd = 0
            data.btc_marketcap = 0
        else:
            data.btc_minerrevntv = coin_btc.revenue
            data.btc_minerrevusd = coin_btc.revenue * coin_btc.priceusd
            data.btc_commitntv = coin_btc.hashrate / (coin_btc.revenue)
            data.btc_commitusd = coin_btc.hashrate / (
                coin_btc.revenue * coin_btc.priceusd
            )
            data.btc_priceusd = coin_btc.priceusd
            data.btc_marketcap = coin_btc.priceusd * coin_btc.supply

        if coin_btc.supply == 0:
            data.btc_minerrevcap = 0
        else:
            data.btc_minerrevcap = 365 * 100 * coin_btc.revenue / coin_btc.supply

        if coin_btc.priceusd:
            if coin_btc.priceusd / 30 > 0.02:
                data.btc_return = coin_btc.priceusd / 30
            else:
                data.btc_return = 0
        else:
            data.btc_return = 0

        if coin_btc.inflation > 0:
            data.btc_inflation = coin_btc.inflation
        else:
            data.btc_inflation = 0
        if coin_btc.supply > 0:
            data.btc_supply = coin_btc.supply
        else:
            data.btc_supply = 0

        if coin_btc.supply - supply_btc < 0.000001:
            data.btc_minerfeesntv = 0
            data.btc_minerfeesusd = 0
            data.btc_emissionntv = 0
        else:
            data.btc_minerfeesntv = coin_btc.revenue - coin_btc.supply + supply_btc
            data.btc_minerfeesusd = (
                coin_btc.revenue - coin_btc.supply + supply_btc
            ) * coin_btc.priceusd
            data.btc_emissionntv = coin_btc.supply - supply_btc

        if (coin_btc.supply - supply_btc) * coin_btc.priceusd < 1000:
            data.btc_emissionusd = 0
        else:
            data.btc_emissionusd = (coin_btc.supply - supply_btc) * coin_btc.priceusd
        supply_btc = coin_btc.supply

        if count_aux > 1750:
            coins_xmr = Coin.objects.filter(name="xmr").filter(date=coin_btc.date)
            if coins_xmr:
                for coin_xmr in coins_xmr:
                    if coin_xmr.blocksize > 0:
                        data.xmr_blocksize = coin_xmr.blocksize
                    else:
                        data.xmr_blocksize = 0

                    if coin_xmr.difficulty > 0:
                        data.xmr_difficulty = coin_xmr.difficulty
                    else:
                        data.xmr_difficulty = 0

                    if coin_xmr.priceusd < 0.001:
                        data.xmr_pricebtc = 0
                        data.xmr_priceusd = 0
                        data.xmr_marketcap = 0
                    else:
                        data.xmr_pricebtc = coin_xmr.pricebtc
                        data.xmr_priceusd = coin_xmr.priceusd
                        data.xmr_marketcap = coin_xmr.priceusd * coin_xmr.supply

                    if coin_btc.supply > 0 and coin_btc.transactions > 0:
                        data.xmr_transactions = coin_xmr.transactions
                        data.xmr_metcalfeusd = (
                            coin_btc.priceusd
                            * coin_xmr.transactions
                            * coin_xmr.supply
                            / (coin_btc.supply * coin_btc.transactions)
                        )
                        data.xmr_metcalfebtc = (
                            coin_xmr.transactions
                            * coin_xmr.supply
                            / (coin_btc.supply * coin_btc.transactions)
                        )
                    else:
                        data.xmr_metcalfeusd = 0
                        data.xmr_metcalfebtc = 0
                        data.xmr_transactions = 0
                    if data.xmr_metcalfeusd < 0.23:
                        data.xmr_metcalfeusd = 0
                        data.xmr_metcalfebtc = 0

                    if coin_xmr.transactions == 0:
                        data.xmr_transacpercentage = 0
                        data.xmr_transcostusd = 0
                        data.xmr_transcostntv = 0
                    else:
                        if (
                            coin_xmr.fee * coin_xmr.priceusd / coin_xmr.transactions
                            < 0.0001
                        ):
                            data.xmr_transcostusd = 0
                            data.xmr_transcostntv = 0
                        else:
                            data.xmr_transcostusd = (
                                coin_xmr.fee * coin_xmr.priceusd / coin_xmr.transactions
                            )
                            data.xmr_transcostntv = coin_xmr.fee / coin_xmr.transactions
                        if coin_btc.transactions == 0:
                            data.xmr_transacpercentage = 0
                        else:
                            data.xmr_transacpercentage = (
                                coin_xmr.transactions / coin_btc.transactions
                            )

                    if coin_xmr.revenue < 0.000001 or coin_xmr.priceusd < 0.001:
                        data.xmr_minerrevntv = 0
                        data.xmr_minerrevusd = 0
                        data.xmr_commitntv = 0
                        data.xmr_commitusd = 0
                    else:
                        data.xmr_minerrevntv = coin_xmr.revenue
                        data.xmr_minerrevusd = coin_xmr.revenue * coin_xmr.priceusd
                        data.xmr_commitntv = coin_xmr.hashrate / (coin_xmr.revenue)
                        data.xmr_commitusd = coin_xmr.hashrate / (
                            coin_xmr.revenue * coin_xmr.priceusd
                        )

                    if coin_xmr.supply == 0:
                        data.xmr_minerrevcap = 0
                    else:
                        data.xmr_minerrevcap = (
                            365 * 100 * coin_xmr.revenue / coin_xmr.supply
                        )

                    if coin_xmr.priceusd / 5.01 > 0.02:
                        data.xmr_return = coin_xmr.priceusd / 5.01
                    else:
                        data.xmr_return = 0

                    if coin_xmr.inflation > 0:
                        data.xmr_inflation = coin_xmr.inflation
                    else:
                        data.xmr_inflation = 0

                    if coin_xmr.supply > 0:
                        data.xmr_supply = coin_xmr.supply
                    else:
                        data.xmr_supply = 0

                    if coin_xmr.supply - supply_xmr < 0.000001:
                        data.xmr_minerfeesntv = 0
                        data.xmr_minerfeesusd = 0
                        data.xmr_emissionntv = 0
                    else:
                        data.xmr_minerfeesntv = (
                            coin_xmr.revenue - coin_xmr.supply + supply_xmr
                        )
                        data.xmr_minerfeesusd = (
                            coin_xmr.revenue - coin_xmr.supply + supply_xmr
                        ) * coin_xmr.priceusd
                        data.xmr_emissionntv = coin_xmr.supply - supply_xmr

                    if (coin_xmr.supply - supply_xmr) * coin_xmr.priceusd < 1000:
                        data.xmr_emissionusd = 0
                    else:
                        data.xmr_emissionusd = (
                            coin_xmr.supply - supply_xmr
                        ) * coin_xmr.priceusd
                    supply_xmr = coin_xmr.supply
            else:
                data.xmr_emissionntv = 0
                data.xmr_emissionusd = 0
                data.xmr_inflation = 0
                data.xmr_supply = 0
                data.xmr_return = 0
                data.xmr_minerrevntv = 0
                data.xmr_minerrevusd = 0
                data.xmr_minerfeesntv = 0
                data.xmr_minerfeesusd = 0
                data.xmr_transcostntv = 0
                data.xmr_transcostusd = 0
                data.xmr_commitntv = 0
                data.xmr_commitusd = 0
                data.xmr_metcalfeusd = 0
                data.xmr_metcalfebtc = 0
                data.xmr_pricebtc = 0
                data.xmr_priceusd = 0
                data.xmr_transacpercentage = 0
                data.xmr_marketcap = 0
                data.xmr_minerrevcap = 0
                data.xmr_transactions = 0
                data.xmr_blocksize = 0
                data.xmr_difficulty = 0

            coins_dash = Coin.objects.filter(name="dash").filter(date=coin_btc.date)
            if coins_dash:
                for coin_dash in coins_dash:
                    if coin_dash.transactions > 0:
                        data.dash_transactions = coin_dash.transactions
                    else:
                        data.dash_transactions = 0
                    if coin_dash.inflation > 0:
                        data.dash_inflation = coin_dash.inflation
                    else:
                        data.dash_inflation = 0

                    if coin_dash.priceusd > 0:
                        data.dash_marketcap = coin_dash.priceusd * coin_dash.supply
                    else:
                        data.dash_marketcap = 0
            else:
                data.dash_inflation = 0
                data.dash_marketcap = 0
                data.dash_transactions = 0
        else:
            data.xmr_emissionntv = 0
            data.xmr_emissionusd = 0
            data.xmr_inflation = 0
            data.xmr_supply = 0
            data.xmr_return = 0
            data.dash_inflation = 0
            data.dash_marketcap = 0
            data.dash_transactions = 0
            data.xmr_marketcap = 0
            data.xmr_minerrevntv = 0
            data.xmr_minerrevusd = 0
            data.xmr_minerfeesntv = 0
            data.xmr_minerfeesusd = 0
            data.xmr_transcostntv = 0
            data.xmr_transcostusd = 0
            data.xmr_commitntv = 0
            data.xmr_commitusd = 0
            data.xmr_metcalfeusd = 0
            data.xmr_metcalfebtc = 0
            data.xmr_pricebtc = 0
            data.xmr_priceusd = 0
            data.xmr_transacpercentage = 0
            data.xmr_minerrevcap = 0
            data.xmr_transactions = 0
            data.xmr_blocksize = 0
            data.xmr_difficulty = 0

        if count_aux > 2800:
            coins_zcash = Coin.objects.filter(name="zec").filter(date=coin_btc.date)
            if coins_zcash:
                for coin_zcash in coins_zcash:
                    if coin_zcash.transactions > 0:
                        data.zcash_transactions = coin_zcash.transactions
                    else:
                        data.zcash_transactions = 0
                    if coin_zcash.inflation > 0:
                        data.zcash_inflation = coin_zcash.inflation
                    else:
                        data.zcash_inflation = 0

                    if coin_zcash.priceusd > 0:
                        data.zcash_marketcap = coin_zcash.priceusd * coin_zcash.supply
                    else:
                        data.zcash_marketcap = 0
            else:
                data.zcash_inflation = 0
                data.zcash_marketcap = 0
                data.zcash_transactions = 0
        else:
            data.zcash_inflation = 0
            data.zcash_marketcap = 0
            data.zcash_transactions = 0

        if count_aux > 3600:
            coins_grin = Coin.objects.filter(name="grin").filter(date=coin_btc.date)
            if coins_grin:
                for coin_grin in coins_grin:
                    if coin_grin.transactions > 0:
                        data.grin_transactions = coin_grin.transactions
                    else:
                        data.grin_transactions = 0
                    if coin_grin.inflation > 0:
                        data.grin_inflation = coin_grin.inflation
                    else:
                        data.grin_inflation = 0

                    if coin_grin.priceusd > 0:
                        data.grin_marketcap = coin_grin.priceusd * coin_grin.supply
                    else:
                        data.grin_marketcap = 0
            else:
                data.grin_inflation = 0
                data.grin_marketcap = 0
                data.grin_transactions = 0
        else:
            data.grin_inflation = 0
            data.grin_marketcap = 0
            data.grin_transactions = 0

        socials = Social.objects.filter(name="Bitcoin").filter(date=coin_btc.date)
        if socials:
            for social in socials:
                data.btc_subscriberCount = social.subscriberCount
                data.btc_commentsPerHour = social.commentsPerHour
                data.btc_postsPerHour = social.postsPerHour
        else:
            data.btc_subscriberCount = 0
            data.btc_commentsPerHour = 0
            data.btc_postsPerHour = 0

        socials = Social.objects.filter(name="Monero").filter(date=coin_btc.date)
        if socials:
            for social in socials:
                data.xmr_subscriberCount = social.subscriberCount
                data.xmr_commentsPerHour = social.commentsPerHour
                data.xmr_postsPerHour = social.postsPerHour
        else:
            data.xmr_subscriberCount = 0
            data.xmr_commentsPerHour = 0
            data.xmr_postsPerHour = 0

        socials = Social.objects.filter(name="CryptoCurrency").filter(
            date=coin_btc.date
        )
        if socials:
            for social in socials:
                data.crypto_subscriberCount = social.subscriberCount
                data.crypto_commentsPerHour = social.commentsPerHour
                data.crypto_postsPerHour = social.postsPerHour
        else:
            data.crypto_subscriberCount = 0
            data.crypto_commentsPerHour = 0
            data.crypto_postsPerHour = 0

        data.save()
        count += 1

    message = "Total of " + str(count) + " data generated"
    context = {"message": message}
    return render(request, "charts/maintenance.html", context)


# Update database with between certain dates
# Only authorized users can do this
@login_required
def update_database_admin(request, date_from, date_to):
    if not request.user.is_superuser:
        return render(request, "users/error.html")

    synchronous.update_database(date_from, date_to)

    message = "Database updated from " + str(date_from) + " to " + str(date_to)
    context = {"message": message}
    return render(request, "charts/maintenance.html", context)
    if not request.user.is_superuser:
        return render(request, "users/error.html")
    count = 0

    ###################################################################
    # SF model charts
    ###################################################################
    print(
        "Populating database for sfmodel.html, sfmodelin.html and pricesats.html, wait a moment..."
    )
    Sfmodel.objects.all().delete()
    timevar = 1283
    v0 = 0.002
    delta = (0.015 - 0.002) / (6 * 365)
    previous_supply = 0
    supply = 0
    sf_aux = 0
    count_aux = 0

    coins = Coin.objects.order_by("date").filter(name="xmr")
    for coin in coins:
        if coin.priceusd < 0.1:
            coin.priceusd = 0.1
            coin.pricebtc = 0.000001
        if coin.stocktoflow > sf_aux * 1.3 + 100:
            coin.stocktoflow = sf_aux

        sf_aux = coin.stocktoflow
        if coin.supply > 0:
            supply = int(coin.supply) * 10**12
        else:
            supply = previous_supply
        count += 1
        count_aux += 1

        data = Sfmodel()
        data.date = coin.date
        data.priceusd = coin.priceusd
        data.pricebtc = coin.pricebtc
        data.stocktoflow = coin.stocktoflow
        data.color = 30 * coin.pricebtc / (count * delta + v0)
        date_aux1 = datetime.datetime.strptime("2017-12-29", "%Y-%m-%d")
        date_aux2 = datetime.datetime.strftime(coin.date, "%Y-%m-%d")
        date_aux2 = datetime.datetime.strptime(date_aux2, "%Y-%m-%d")
        if date_aux2 < date_aux1:
            lastprice = coin.priceusd
            current_inflation = coin.inflation
            data.greyline = 0
            count_aux = 0
        else:
            day = date_aux2 - timedelta(timevar)
            coin_aux1 = Coin.objects.filter(name="xmr").get(date=day)
            day = date_aux2 - timedelta(timevar + 1)
            coin_aux2 = Coin.objects.filter(name="xmr").get(date=day)
            date_aux3 = datetime.datetime.strptime("2017-12-29", "%Y-%m-%d")

            if date_aux3 + timedelta(int(count_aux * 2)) < datetime.datetime.strptime(
                "2021-07-03", "%Y-%m-%d"
            ):
                day = date_aux3 + timedelta(int(count_aux * 2))
                coin_aux3 = Coin.objects.filter(name="xmr").get(date=day)
                if coin_aux3:
                    if (coin_aux3.inflation / current_inflation) > 1.2 or (
                        coin_aux3.inflation / current_inflation
                    ) < 0.8:
                        coin_aux3.inflation = current_inflation
                    else:
                        current_inflation = coin_aux3.inflation
                supply2 = supply
            else:
                reward2 = (2**64 - 1 - supply2) >> 19
                if reward2 < 0.6 * (10**12):
                    reward2 = 0.6 * (10**12)
                supply2 += int(720 * reward2)
                current_inflation = 100 * reward2 * 720 * 365 / supply2

            if coin_aux1 and coin_aux2:
                lastprice += (coin_aux1.priceusd / coin_aux2.priceusd - 1) * lastprice
                actualprice = lastprice * (
                    math.sqrt(coin.inflation / current_inflation)
                )
                data.greyline = actualprice
            else:
                data.greyline = 0
            previous_supply = supply
        data.save()

    count_aux = 0
    for count_aux in range(700):
        date_now = date.today() + timedelta(count_aux)
        reward = (2**64 - 1 - supply) >> 19
        if reward < 0.6 * (10**12):
            reward = 0.6 * (10**12)
        supply += int(720 * reward)

        data = Sfmodel()
        data.date = datetime.datetime.strftime(date_now, "%Y-%m-%d")
        data.stocktoflow = (100 / (100 * reward * 720 * 365 / supply)) ** 1.65
        data.priceusd = 0
        data.pricebtc = 0
        data.greyline = 0
        data.color = 0
        data.priceusd = 0
        data.greyline = 0
        data.save()
        count += 1

    ###################################################################
    # Daily Emissions, inflation charts and coins against bitcoin
    ###################################################################
    print(
        "Populating database for dailyemission.html and dailyemissionntv.html, wait a moment..."
    )
    DailyData.objects.all().delete()
    supply_btc = 0
    supply_xmr = 0
    count_aux = 0
    coins_btc = Coin.objects.order_by("date").filter(name="btc")

    for coin_btc in coins_btc:
        count_aux += 1
        data = DailyData()
        data.date = datetime.datetime.strftime(coin_btc.date, "%Y-%m-%d")

        if coin_btc.blocksize > 0:
            data.btc_blocksize = coin_btc.blocksize
            data.btc_transactions = coin_btc.transactions
        else:
            data.btc_blocksize = 0
            data.btc_transactions = 0

        if coin_btc.difficulty > 0:
            data.btc_difficulty = coin_btc.difficulty
        else:
            data.btc_difficulty = 0

        if coin_btc.transactions == 0:
            data.btc_transcostusd = 0
            data.btc_transcostntv = 0
        else:
            if coin_btc.fee * coin_btc.priceusd / coin_btc.transactions < 0.0001:
                data.btc_transcostusd = 0
                data.btc_transcostntv = 0
            else:
                data.btc_transcostusd = (
                    coin_btc.fee * coin_btc.priceusd / coin_btc.transactions
                )
                data.btc_transcostntv = coin_btc.fee / coin_btc.transactions

        if coin_btc.revenue < 0.000001 or coin_btc.priceusd < 0.001:
            data.btc_minerrevntv = 0
            data.btc_minerrevusd = 0
            data.btc_commitntv = 0
            data.btc_commitusd = 0
            data.btc_priceusd = 0
            data.btc_marketcap = 0
        else:
            data.btc_minerrevntv = coin_btc.revenue
            data.btc_minerrevusd = coin_btc.revenue * coin_btc.priceusd
            data.btc_commitntv = coin_btc.hashrate / (coin_btc.revenue)
            data.btc_commitusd = coin_btc.hashrate / (
                coin_btc.revenue * coin_btc.priceusd
            )
            data.btc_priceusd = coin_btc.priceusd
            data.btc_marketcap = coin_btc.priceusd * coin_btc.supply

        if coin_btc.supply == 0:
            data.btc_minerrevcap = 0
        else:
            data.btc_minerrevcap = 365 * 100 * coin_btc.revenue / coin_btc.supply

        if coin_btc.priceusd:
            if coin_btc.priceusd / 30 > 0.02:
                data.btc_return = coin_btc.priceusd / 30
            else:
                data.btc_return = 0
        else:
            data.btc_return = 0

        if coin_btc.inflation > 0:
            data.btc_inflation = coin_btc.inflation
        else:
            data.btc_inflation = 0
        if coin_btc.supply > 0:
            data.btc_supply = coin_btc.supply
        else:
            data.btc_supply = 0

        if coin_btc.supply - supply_btc < 0.000001:
            data.btc_minerfeesntv = 0
            data.btc_minerfeesusd = 0
            data.btc_emissionntv = 0
        else:
            data.btc_minerfeesntv = coin_btc.revenue - coin_btc.supply + supply_btc
            data.btc_minerfeesusd = (
                coin_btc.revenue - coin_btc.supply + supply_btc
            ) * coin_btc.priceusd
            data.btc_emissionntv = coin_btc.supply - supply_btc

        if (coin_btc.supply - supply_btc) * coin_btc.priceusd < 1000:
            data.btc_emissionusd = 0
        else:
            data.btc_emissionusd = (coin_btc.supply - supply_btc) * coin_btc.priceusd
        supply_btc = coin_btc.supply

        if count_aux > 1750:
            coins_xmr = Coin.objects.filter(name="xmr").filter(date=coin_btc.date)
            if coins_xmr:
                for coin_xmr in coins_xmr:
                    if coin_xmr.blocksize > 0:
                        data.xmr_blocksize = coin_xmr.blocksize
                    else:
                        data.xmr_blocksize = 0

                    if coin_xmr.difficulty > 0:
                        data.xmr_difficulty = coin_xmr.difficulty
                    else:
                        data.xmr_difficulty = 0

                    if coin_xmr.priceusd < 0.001:
                        data.xmr_pricebtc = 0
                        data.xmr_priceusd = 0
                        data.xmr_marketcap = 0
                    else:
                        data.xmr_pricebtc = coin_xmr.pricebtc
                        data.xmr_priceusd = coin_xmr.priceusd
                        data.xmr_marketcap = coin_xmr.priceusd * coin_xmr.supply

                    if coin_btc.supply > 0 and coin_btc.transactions > 0:
                        data.xmr_transactions = coin_xmr.transactions
                        data.xmr_metcalfeusd = (
                            coin_btc.priceusd
                            * coin_xmr.transactions
                            * coin_xmr.supply
                            / (coin_btc.supply * coin_btc.transactions)
                        )
                        data.xmr_metcalfebtc = (
                            coin_xmr.transactions
                            * coin_xmr.supply
                            / (coin_btc.supply * coin_btc.transactions)
                        )
                    else:
                        data.xmr_metcalfeusd = 0
                        data.xmr_metcalfebtc = 0
                        data.xmr_transactions = 0
                    if data.xmr_metcalfeusd < 0.23:
                        data.xmr_metcalfeusd = 0
                        data.xmr_metcalfebtc = 0

                    if coin_xmr.transactions == 0:
                        data.xmr_transacpercentage = 0
                        data.xmr_transcostusd = 0
                        data.xmr_transcostntv = 0
                    else:
                        if (
                            coin_xmr.fee * coin_xmr.priceusd / coin_xmr.transactions
                            < 0.0001
                        ):
                            data.xmr_transcostusd = 0
                            data.xmr_transcostntv = 0
                        else:
                            data.xmr_transcostusd = (
                                coin_xmr.fee * coin_xmr.priceusd / coin_xmr.transactions
                            )
                            data.xmr_transcostntv = coin_xmr.fee / coin_xmr.transactions
                        if coin_btc.transactions == 0:
                            data.xmr_transacpercentage = 0
                        else:
                            data.xmr_transacpercentage = (
                                coin_xmr.transactions / coin_btc.transactions
                            )

                    if coin_xmr.revenue < 0.000001 or coin_xmr.priceusd < 0.001:
                        data.xmr_minerrevntv = 0
                        data.xmr_minerrevusd = 0
                        data.xmr_commitntv = 0
                        data.xmr_commitusd = 0
                    else:
                        data.xmr_minerrevntv = coin_xmr.revenue
                        data.xmr_minerrevusd = coin_xmr.revenue * coin_xmr.priceusd
                        data.xmr_commitntv = coin_xmr.hashrate / (coin_xmr.revenue)
                        data.xmr_commitusd = coin_xmr.hashrate / (
                            coin_xmr.revenue * coin_xmr.priceusd
                        )

                    if coin_xmr.supply == 0:
                        data.xmr_minerrevcap = 0
                    else:
                        data.xmr_minerrevcap = (
                            365 * 100 * coin_xmr.revenue / coin_xmr.supply
                        )

                    if coin_xmr.priceusd / 5.01 > 0.02:
                        data.xmr_return = coin_xmr.priceusd / 5.01
                    else:
                        data.xmr_return = 0

                    if coin_xmr.inflation > 0:
                        data.xmr_inflation = coin_xmr.inflation
                    else:
                        data.xmr_inflation = 0

                    if coin_xmr.supply > 0:
                        data.xmr_supply = coin_xmr.supply
                    else:
                        data.xmr_supply = 0

                    if coin_xmr.supply - supply_xmr < 0.000001:
                        data.xmr_minerfeesntv = 0
                        data.xmr_minerfeesusd = 0
                        data.xmr_emissionntv = 0
                    else:
                        data.xmr_minerfeesntv = (
                            coin_xmr.revenue - coin_xmr.supply + supply_xmr
                        )
                        data.xmr_minerfeesusd = (
                            coin_xmr.revenue - coin_xmr.supply + supply_xmr
                        ) * coin_xmr.priceusd
                        data.xmr_emissionntv = coin_xmr.supply - supply_xmr

                    if (coin_xmr.supply - supply_xmr) * coin_xmr.priceusd < 1000:
                        data.xmr_emissionusd = 0
                    else:
                        data.xmr_emissionusd = (
                            coin_xmr.supply - supply_xmr
                        ) * coin_xmr.priceusd
                    supply_xmr = coin_xmr.supply
            else:
                data.xmr_emissionntv = 0
                data.xmr_emissionusd = 0
                data.xmr_inflation = 0
                data.xmr_supply = 0
                data.xmr_return = 0
                data.xmr_minerrevntv = 0
                data.xmr_minerrevusd = 0
                data.xmr_minerfeesntv = 0
                data.xmr_minerfeesusd = 0
                data.xmr_transcostntv = 0
                data.xmr_transcostusd = 0
                data.xmr_commitntv = 0
                data.xmr_commitusd = 0
                data.xmr_metcalfeusd = 0
                data.xmr_metcalfebtc = 0
                data.xmr_pricebtc = 0
                data.xmr_priceusd = 0
                data.xmr_transacpercentage = 0
                data.xmr_marketcap = 0
                data.xmr_minerrevcap = 0
                data.xmr_transactions = 0
                data.xmr_blocksize = 0
                data.xmr_difficulty = 0

            coins_dash = Coin.objects.filter(name="dash").filter(date=coin_btc.date)
            if coins_dash:
                for coin_dash in coins_dash:
                    if coin_dash.transactions > 0:
                        data.dash_transactions = coin_dash.transactions
                    else:
                        data.dash_transactions = 0
                    if coin_dash.inflation > 0:
                        data.dash_inflation = coin_dash.inflation
                    else:
                        data.dash_inflation = 0

                    if coin_dash.priceusd > 0:
                        data.dash_marketcap = coin_dash.priceusd * coin_dash.supply
                    else:
                        data.dash_marketcap = 0
            else:
                data.dash_inflation = 0
                data.dash_marketcap = 0
                data.dash_transactions = 0
        else:
            data.xmr_emissionntv = 0
            data.xmr_emissionusd = 0
            data.xmr_inflation = 0
            data.xmr_supply = 0
            data.xmr_return = 0
            data.dash_inflation = 0
            data.dash_marketcap = 0
            data.dash_transactions = 0
            data.xmr_marketcap = 0
            data.xmr_minerrevntv = 0
            data.xmr_minerrevusd = 0
            data.xmr_minerfeesntv = 0
            data.xmr_minerfeesusd = 0
            data.xmr_transcostntv = 0
            data.xmr_transcostusd = 0
            data.xmr_commitntv = 0
            data.xmr_commitusd = 0
            data.xmr_metcalfeusd = 0
            data.xmr_metcalfebtc = 0
            data.xmr_pricebtc = 0
            data.xmr_priceusd = 0
            data.xmr_transacpercentage = 0
            data.xmr_minerrevcap = 0
            data.xmr_transactions = 0
            data.xmr_blocksize = 0
            data.xmr_difficulty = 0

        if count_aux > 2800:
            coins_zcash = Coin.objects.filter(name="zec").filter(date=coin_btc.date)
            if coins_zcash:
                for coin_zcash in coins_zcash:
                    if coin_zcash.transactions > 0:
                        data.zcash_transactions = coin_zcash.transactions
                    else:
                        data.zcash_transactions = 0
                    if coin_zcash.inflation > 0:
                        data.zcash_inflation = coin_zcash.inflation
                    else:
                        data.zcash_inflation = 0

                    if coin_zcash.priceusd > 0:
                        data.zcash_marketcap = coin_zcash.priceusd * coin_zcash.supply
                    else:
                        data.zcash_marketcap = 0
            else:
                data.zcash_inflation = 0
                data.zcash_marketcap = 0
                data.zcash_transactions = 0
        else:
            data.zcash_inflation = 0
            data.zcash_marketcap = 0
            data.zcash_transactions = 0

        if count_aux > 3600:
            coins_grin = Coin.objects.filter(name="grin").filter(date=coin_btc.date)
            if coins_grin:
                for coin_grin in coins_grin:
                    if coin_grin.transactions > 0:
                        data.grin_transactions = coin_grin.transactions
                    else:
                        data.grin_transactions = 0
                    if coin_grin.inflation > 0:
                        data.grin_inflation = coin_grin.inflation
                    else:
                        data.grin_inflation = 0

                    if coin_grin.priceusd > 0:
                        data.grin_marketcap = coin_grin.priceusd * coin_grin.supply
                    else:
                        data.grin_marketcap = 0
            else:
                data.grin_inflation = 0
                data.grin_marketcap = 0
                data.grin_transactions = 0
        else:
            data.grin_inflation = 0
            data.grin_marketcap = 0
            data.grin_transactions = 0

        socials = Social.objects.filter(name="Bitcoin").filter(date=coin_btc.date)
        if socials:
            for social in socials:
                data.btc_subscriberCount = social.subscriberCount
                data.btc_commentsPerHour = social.commentsPerHour
                data.btc_postsPerHour = social.postsPerHour
        else:
            data.btc_subscriberCount = 0
            data.btc_commentsPerHour = 0
            data.btc_postsPerHour = 0

        socials = Social.objects.filter(name="Monero").filter(date=coin_btc.date)
        if socials:
            for social in socials:
                data.xmr_subscriberCount = social.subscriberCount
                data.xmr_commentsPerHour = social.commentsPerHour
                data.xmr_postsPerHour = social.postsPerHour
        else:
            data.xmr_subscriberCount = 0
            data.xmr_commentsPerHour = 0
            data.xmr_postsPerHour = 0

        socials = Social.objects.filter(name="CryptoCurrency").filter(
            date=coin_btc.date
        )
        if socials:
            for social in socials:
                data.crypto_subscriberCount = social.subscriberCount
                data.crypto_commentsPerHour = social.commentsPerHour
                data.crypto_postsPerHour = social.postsPerHour
        else:
            data.crypto_subscriberCount = 0
            data.crypto_commentsPerHour = 0
            data.crypto_postsPerHour = 0

        data.save()
        count += 1

    message = "Total of " + str(count) + " data generated"
    context = {"message": message}
    return render(request, "charts/maintenance.html", context)


####################################################################################
#   Views
####################################################################################
async def index(request):
    coins = Coin.objects.filter(name="xmr").order_by("-date")
    count = 0
    for coin in coins:
        count += 1
        if count < 200:
            if coin.supply < 18000000:
                coin.supply += 499736
                print(coin.date)
                coin.save()

    coin = list(Coin.objects.order_by("-date"))[0]
    if not (coin):
        message = "Website under maintenance. Check back in a few minutes"
        context = {"message": message}
        return render(request, "charts/maintenance.html", context)

    now = int(datetime.datetime.now().strftime("%H"))
    yesterday = datetime.datetime.strftime(date.today() - timedelta(1), "%Y-%m-%d")
    date_aux = datetime.datetime.strftime(date.today() - timedelta(2), "%Y-%m-%d")
    update_xmr = False
    update_btc = False
    update_socials = False  # TODO: What is this for?  # noqa: F841
    update_data = False

    if now > 2 and now < 12:
        try:
            coin_xmr = Coin.objects.filter(name="xmr").get(date=yesterday)
            if coin_xmr:
                print("xmr found yesterday")
                if (
                    coin_xmr.priceusd > 1
                    and coin_xmr.transactions > 0
                    and coin_xmr.inflation > 0
                ):
                    print("no need to update xmr")
                    update_xmr = False
                else:
                    print("will update xmr")
                    coin_xmr.delete()
                    update_xmr = True
            else:
                print("no xmr found yesterday - 1")
                update_xmr = True
        except Exception:
            print("no xmr found yesterday - 2")
            update_xmr = True
    if now > 6 and now < 12:
        try:
            coin_btc = list(Coin.objects.filter(name="btc").filter(date=yesterday))[0]
            coin_zec = list(Coin.objects.filter(name="zec").filter(date=yesterday))[0]
            coin_dash = list(Coin.objects.filter(name="dash").filter(date=yesterday))[0]
            coin_grin = list(Coin.objects.filter(name="grin").filter(date=yesterday))[0]
            if coin_btc and coin_zec and coin_dash and coin_grin:
                print("coins found yesterday")
                if (
                    coin_btc.transactions > 0
                    and coin_btc.inflation > 0
                    and coin_zec.supply > 0
                    and coin_dash.supply > 0
                    and coin_grin.supply > 0
                ):
                    print("no need to update coins")
                    update_btc = False
                else:
                    print("will update coins")
                    coin_btc.delete()
                    coin_zec.delete()
                    coin_dash.delete()
                    coin_grin.delete()
                    update_btc = True
            else:
                print("no coins found yesterday - 1")
                update_btc = True
        except Exception:
            print("no coins found yesterday - 2")
            update_btc = True
        try:
            data = list(DailyData.objects.filter(date=yesterday))[0]
            if data:
                print("data found yesterday")
                update_data = False
            else:
                print("no data found yesterday - 1")
                update_data = True
        except Exception:
            print("no data found yesterday - 2")
            update_data = True

    try:
        coin_xmr = Coin.objects.filter(name="xmr").get(date=date_aux)
    except Exception:
        coin_xmr = list(Coin.objects.filter(name="xmr").order_by("-date"))[0]

    if update_xmr:
        count = get_history_function("xmr", yesterday, yesterday)
        await asynchronous.update_xmr_data(yesterday, coin_xmr)

    if update_btc:
        await asynchronous.update_others_data(yesterday)

    if update_data:
        synchronous.update_database(yesterday, yesterday)

    if True:
        enabled = synchronous.get_binance_withdrawal(  # TODO: And... then... what? # noqa: F841
            "Monero"
        )

    return HttpResponseRedirect(reverse("charts:sfmodel"))


def social(request):
    data = DailyData.objects.order_by("date")
    dates = []
    dates2 = []
    social_xmr = []
    social_crypto = []
    social_btc = []
    last_xmr = 0
    last_btc = 0
    last_crypto = 0

    for item in data:
        dates.append(datetime.datetime.strftime(item.date, "%Y-%m-%d"))
        dates2.append(datetime.datetime.strftime(item.date, "%Y-%m-%d"))

        if item.btc_subscriberCount > last_btc:
            social_btc.append(item.btc_subscriberCount)
            last_btc = item.btc_subscriberCount
        else:
            social_btc.append(last_btc)

        if item.xmr_subscriberCount > last_xmr:
            social_xmr.append(item.xmr_subscriberCount)
            last_xmr = item.xmr_subscriberCount
        else:
            social_xmr.append(last_xmr)

        if item.crypto_subscriberCount > last_crypto:
            social_crypto.append(item.crypto_subscriberCount)
            last_crypto = item.crypto_subscriberCount
        else:
            social_crypto.append(last_crypto)

    last_xmr = locale.format("%.0f", last_xmr, grouping=True)
    last_btc = locale.format("%.0f", last_btc, grouping=True)
    last_crypto = locale.format("%.0f", last_crypto, grouping=True)

    context = {
        "dates": dates,
        "dates2": dates2,
        "social_xmr": social_xmr,
        "social_crypto": social_crypto,
        "social_btc": social_btc,
        "last_xmr": last_xmr,
        "last_btc": last_btc,
        "last_crypto": last_crypto,
    }
    return render(request, "charts/social.html", context)


def social2(request):
    data = DailyData.objects.order_by("date")
    dates = []
    social_btc = []
    last_btc = 0
    dates2 = []
    social_xmr = []
    last_xmr = 0
    N = 1

    for item in data:
        dates.append(datetime.datetime.strftime(item.date, "%Y-%m-%d"))
        dates2.append(datetime.datetime.strftime(item.date, "%Y-%m-%d"))

        if item.btc_subscriberCount > 0:
            if item.btc_marketcap > 10000:
                last_btc = ((item.btc_marketcap) ** N) / item.btc_subscriberCount
                social_btc.append(last_btc)
            else:
                social_btc.append("")
        else:
            social_btc.append(last_btc)

        if item.xmr_subscriberCount > 0:
            if item.xmr_marketcap > 10000:
                last_xmr = ((item.xmr_marketcap) ** N) / item.xmr_subscriberCount
                social_xmr.append(last_xmr)
            else:
                social_xmr.append("")

        else:
            social_xmr.append(last_xmr)

    last_xmr = "$" + locale.format("%.0f", last_xmr, grouping=True)
    last_btc = "$" + locale.format("%.0f", last_btc, grouping=True)

    context = {
        "dates": dates,
        "dates2": dates2,
        "social_btc": social_btc,
        "social_xmr": social_xmr,
        "last_xmr": last_xmr,
        "last_btc": last_btc,
    }
    return render(request, "charts/social2.html", context)


def social3(request):
    data = DailyData.objects.order_by("date")

    dates = []
    social_xmr = []
    social_crypto = []
    last_xmr = 0
    last_crypto = 0

    for item in data:
        dates.append(datetime.datetime.strftime(item.date, "%Y-%m-%d"))

        if item.btc_subscriberCount > 0 and item.xmr_subscriberCount > 0:
            last_xmr = 100 * (item.xmr_subscriberCount / item.btc_subscriberCount)
            social_xmr.append(last_xmr)
        else:
            social_xmr.append(last_xmr)

        if item.btc_subscriberCount > 0 and item.crypto_subscriberCount > 0:
            last_crypto = 100 * (item.crypto_subscriberCount / item.btc_subscriberCount)
            social_crypto.append(last_crypto)
        else:
            social_crypto.append(last_crypto)

    last_xmr = locale.format("%.1f", last_xmr, grouping=True) + "%"
    last_crypto = locale.format("%.1f", last_crypto, grouping=True) + "%"

    context = {
        "dates": dates,
        "social_xmr": social_xmr,
        "social_crypto": social_crypto,
        "last_xmr": last_xmr,
        "last_crypto": last_crypto,
    }
    return render(request, "charts/social3.html", context)


def social4(request):
    data = DailyData.objects.order_by("date")
    dates = []
    dates2 = []
    social_xmr = []
    social_crypto = []
    social_btc = []
    last_xmr = 0
    last_btc = 0
    last_crypto = 0

    for item in data:
        dates.append(datetime.datetime.strftime(item.date, "%Y-%m-%d"))
        dates2.append(datetime.datetime.strftime(item.date, "%Y-%m-%d"))

        if item.btc_subscriberCount > last_btc:
            social_btc.append(item.btc_subscriberCount)
            last_btc = item.btc_subscriberCount
        else:
            social_btc.append(last_btc)

        if item.xmr_subscriberCount > last_xmr:
            social_xmr.append(item.xmr_subscriberCount)
            last_xmr = item.xmr_subscriberCount
        else:
            social_xmr.append(last_xmr)

        if item.crypto_subscriberCount > last_crypto:
            social_crypto.append(item.crypto_subscriberCount)
            last_crypto = item.crypto_subscriberCount
        else:
            social_crypto.append(last_crypto)

    N = 30
    last_btc = ""
    speed_btc = []
    for i in range(len(social_btc)):
        if i < N:
            speed_btc.append(last_btc)
        else:
            if social_btc[i - N] != 0 and social_btc[i] - social_btc[i - N] != 0:
                last_btc = 100 * (social_btc[i] - social_btc[i - N]) / social_btc[i - N]
                if last_btc < 0.2:
                    last_btc = 0.2
                if last_btc > 1000:
                    last_btc = ""
            else:
                last_btc = ""
            speed_btc.append(last_btc)

    last_btc = ""
    newcomers_btc = []
    for i in range(len(social_btc)):
        if i < N:
            newcomers_btc.append(last_btc)
        else:
            last_btc = social_btc[i] - social_btc[i - N]
            if last_btc < 10:
                last_btc = ""
            newcomers_btc.append(last_btc)

    last_crypto = ""
    speed_crypto = []
    for i in range(len(social_crypto)):
        if i < N:
            speed_crypto.append(last_crypto)
        else:
            if (
                social_crypto[i - N] != 0
                and social_crypto[i] - social_crypto[i - N] != 0
            ):
                last_crypto = (
                    100
                    * (social_crypto[i] - social_crypto[i - N])
                    / social_crypto[i - N]
                )
                if last_crypto < 0.2:
                    last_crypto = 0.2
                if last_crypto > 1000:
                    last_crypto = ""
            else:
                last_crypto = ""
            speed_crypto.append(last_crypto)

    last_crypto = ""
    newcomers_crypto = []
    for i in range(len(social_crypto)):
        if i < N:
            newcomers_crypto.append(last_crypto)
        else:
            last_crypto = social_crypto[i] - social_crypto[i - N]
            if last_crypto < 2:
                last_crypto = ""
            newcomers_crypto.append(last_crypto)

    last_xmr = ""
    speed_xmr = []
    for i in range(len(social_xmr)):
        if i < N:
            speed_xmr.append(last_xmr)
        else:
            if social_xmr[i - N] != 0 and social_xmr[i] - social_xmr[i - N] != 0:
                last_xmr = 100 * (social_xmr[i] - social_xmr[i - N]) / social_xmr[i - N]
                if last_xmr < 0.2:
                    last_xmr = 0.2
                if last_xmr > 1000:
                    last_xmr = ""
            else:
                last_xmr = ""
            speed_xmr.append(last_xmr)

    last_xmr = ""
    newcomers_xmr = []
    for i in range(len(social_xmr)):
        if i < N:
            newcomers_xmr.append(last_xmr)
        else:
            last_xmr = social_xmr[i] - social_xmr[i - N]
            if last_xmr < 0:
                last_xmr = ""
            newcomers_xmr.append(last_xmr)

    try:
        last_xmr = locale.format("%.0f", last_xmr, grouping=True)
        last_btc = locale.format("%.0f", last_btc, grouping=True)
        last_crypto = locale.format("%.0f", last_crypto, grouping=True)
    except Exception:
        last_xmr = 0
        last_btc = 0
        last_crypto = 0

    context = {
        "dates": dates,
        "speed_xmr": speed_xmr,
        "speed_crypto": speed_crypto,
        "speed_btc": speed_btc,
        "newcomers_xmr": newcomers_xmr,
        "newcomers_btc": newcomers_btc,
        "newcomers_crypto": newcomers_crypto,
        "last_xmr": last_xmr,
        "last_btc": last_btc,
        "last_crypto": last_crypto,
    }
    return render(request, "charts/social4.html", context)


def social5(request):
    data = DailyData.objects.order_by("date")
    transactions = []
    dates = []
    social_xmr = []
    now_transactions = 0
    last_xmr = 0

    for item in data:
        dates.append(datetime.datetime.strftime(item.date, "%Y-%m-%d"))

        if item.xmr_subscriberCount > last_xmr:
            social_xmr.append(item.xmr_subscriberCount)
            last_xmr = item.xmr_subscriberCount
        else:
            social_xmr.append(last_xmr)

        if item.xmr_transactions > 300:
            now_transactions = item.xmr_transactions
            transactions.append(now_transactions)
        else:
            transactions.append("")

    last_xmr = locale.format("%.0f", last_xmr, grouping=True)
    now_transactions = locale.format("%.0f", now_transactions, grouping=True)

    context = {
        "dates": dates,
        "social_xmr": social_xmr,
        "last_xmr": last_xmr,
        "now_transactions": now_transactions,
        "transactions": transactions,
    }
    return render(request, "charts/social5.html", context)


def social6(request):
    data = DailyData.objects.order_by("date")
    dates = []
    social_xmr = []
    social_crypto = []
    social_btc = []
    last_xmr = 0
    last_btc = 0
    last_crypto = 0

    for item in data:
        dates.append(datetime.datetime.strftime(item.date, "%Y-%m-%d"))

        if item.btc_commentsPerHour * 24 < last_btc / 4:
            social_btc.append(last_btc)
        else:
            last_btc = item.btc_commentsPerHour * 24
            social_btc.append(last_btc)

        if item.xmr_commentsPerHour * 24 < last_xmr / 4:
            social_xmr.append(last_xmr)
        else:
            last_xmr = item.xmr_commentsPerHour * 24
            social_xmr.append(last_xmr)

        if item.crypto_commentsPerHour * 24 < last_crypto / 4:
            social_crypto.append(last_crypto)
        else:
            last_crypto = item.crypto_commentsPerHour * 24
            social_crypto.append(last_crypto)

    last_xmr = locale.format("%.0f", last_xmr, grouping=True)
    last_btc = locale.format("%.0f", last_btc, grouping=True)
    last_crypto = locale.format("%.0f", last_crypto, grouping=True)

    context = {
        "dates": dates,
        "social_xmr": social_xmr,
        "social_crypto": social_crypto,
        "social_btc": social_btc,
        "last_xmr": last_xmr,
        "last_btc": last_btc,
        "last_crypto": last_crypto,
    }
    return render(request, "charts/social6.html", context)


def social7(request):
    data = DailyData.objects.order_by("date")
    dates = []
    social_xmr = []
    social_crypto = []
    social_btc = []
    last_xmr = 0
    last_btc = 0
    last_crypto = 0

    for item in data:
        dates.append(datetime.datetime.strftime(item.date, "%Y-%m-%d"))
        if item.btc_postsPerHour > 0:
            last_btc = item.btc_postsPerHour * 24
            social_btc.append(last_btc)
        else:
            social_btc.append(last_btc)

        if item.xmr_postsPerHour > 0:
            last_xmr = item.xmr_postsPerHour * 24
            social_xmr.append(last_xmr)
        else:
            social_xmr.append(last_xmr)

        if item.crypto_postsPerHour > 0:
            last_crypto = item.crypto_postsPerHour * 24
            social_crypto.append(last_crypto)
        else:
            social_crypto.append(last_crypto)

    last_xmr = locale.format("%.0f", last_xmr, grouping=True)
    last_btc = locale.format("%.0f", last_btc, grouping=True)
    last_crypto = locale.format("%.0f", last_crypto, grouping=True)

    context = {
        "dates": dates,
        "social_xmr": social_xmr,
        "social_crypto": social_crypto,
        "social_btc": social_btc,
        "last_xmr": last_xmr,
        "last_btc": last_btc,
        "last_crypto": last_crypto,
    }
    return render(request, "charts/social7.html", context)


def pricelog(request):
    symbol = "xmr"
    now_price = 0
    now_sf = 0
    now_inflation = 0
    v0 = 0.002
    delta = (0.015 - 0.002) / (6 * 365)
    count = 0
    maximum = 0
    supply = 0
    dates = []
    color = []
    values = []

    coins = Coin.objects.order_by("date").filter(name=symbol)
    for coin in coins:
        dates.append(datetime.datetime.strftime(coin.date, "%Y-%m-%d"))
        values.append(coin.priceusd)
        if coin.priceusd < 0.01:
            coin.priceusd = 0.01
        if coin.stocktoflow < 0.1:
            coin.stocktoflow = 0.1
        now_inflation = coin.inflation
        now_price = coin.priceusd
        now_sf = coin.stocktoflow
        if now_price > maximum:
            maximum = now_price
        new_color = 30 * coin.pricebtc / (count * delta + v0)
        color.append(new_color)
        supply = int(coin.supply) * 10**12
        count += 1

    count = 0
    for count in range(650):
        date_now = date.today() + timedelta(count)
        dates.append(datetime.datetime.strftime(date_now, "%Y-%m-%d"))
        reward = (2**64 - 1 - supply) >> 19
        if reward < 0.6 * (10**12):
            reward = 0.6 * (10**12)
        supply += int(720 * reward)

    now_price = "$" + locale.format("%.2f", now_price, grouping=True)
    now_sf = "$" + locale.format("%.2f", now_sf, grouping=True)
    maximum = "$" + locale.format("%.2f", maximum, grouping=True)
    now_inflation = locale.format("%.2f", now_inflation, grouping=True) + "%"

    context = {
        "values": values,
        "dates": dates,
        "maximum": maximum,
        "now_price": now_price,
        "now_inflation": now_inflation,
        "now_sf": now_sf,
        "color": color,
    }
    return render(request, "charts/pricelog.html", context)


def movingaverage(request):
    symbol = "xmr"
    v0 = 0.002  # TODO: Unused? # noqa: F841
    delta = (0.015 - 0.002) / (6 * 365)  # TODO # noqa: F841
    count = 0
    dates = []
    color = []
    values = []
    average1 = []
    average2 = []
    total = 0

    coins = Coin.objects.order_by("date").filter(name=symbol)
    for coin in coins:
        dates.append(datetime.datetime.strftime(coin.date, "%Y-%m-%d"))
        if coin.priceusd < 0.2:
            coin.priceusd = 0.2
        total += coin.priceusd
        values.append(coin.priceusd)
        if count < 1460:
            aux = total / (730 + count / 2)
            if aux < 0.2:
                aux = 0.2
            average1.append(aux)
            average2.append(aux * 5)
            if coin.priceusd > 5 * aux:
                new_color = 1
            if coin.priceusd < aux:
                new_color = 0
            else:
                new_color = coin.priceusd / (5 * aux)
            color.append(new_color)
        else:
            color.append(new_color)

        count += 1

    n = 1460
    median = pd.Series(values).rolling(window=n).mean().iloc[n - 1 :].values

    # for count in range(1460):
    #    average1.append('')
    #    average2.append('')
    for item in median:
        average1.append(item)
        average2.append(item * 5)

    context = {
        "values": values,
        "dates": dates,
        "color": color,
        "average1": average1,
        "average2": average2,
    }
    return render(request, "charts/movingaverage.html", context)


def powerlaw(request):
    symbol = "xmr"
    now_price = 0
    now_sf = 0
    now_inflation = 0
    v0 = 0.002
    delta = (0.015 - 0.002) / (6 * 365)
    count = 0
    maximum = 0
    dates = []
    counter = []
    years = []
    line3 = []
    line2 = []
    line1 = []
    a3 = 0.00000000000000000009
    a2 = 0.0000000000000000000000008
    a1 = 0.00000000000000000000000002
    b3 = (math.log(477, 10) - math.log(5.01, 10)) / (
        math.log(2511, 10) - math.log(1231, 10)
    )
    b2 = (math.log(92, 10) - math.log(0.23, 10)) / (
        math.log(3297, 10) - math.log(1468, 10)
    )
    b1 = (math.log(93, 10) - math.log(0.39, 10)) / (
        math.log(3570, 10) - math.log(1755, 10)
    )
    color = []
    values = []

    yearnumber = 2014
    days = 1200
    coins = Coin.objects.order_by("date").filter(name=symbol)
    for coin in coins:
        if coin.priceusd < 0.01:
            continue
        days += 1
        price3 = a3 * (days**b3)
        price2 = a2 * (days**b2)
        price1 = a1 * (days**b1)
        line3.append(price3)
        line2.append(price2)
        line1.append(price1)
        counter.append(days)
        if coin.date.year > yearnumber:
            yearnumber += 1
            years.append(yearnumber)
            dates.append(days)
        values.append(coin.priceusd)
        if coin.priceusd < 0.01:
            coin.priceusd = 0.01
        if coin.stocktoflow < 0.1:
            coin.stocktoflow = 0.1
        now_inflation = coin.inflation
        now_price = coin.priceusd
        now_sf = coin.stocktoflow
        if now_price > maximum:
            maximum = now_price
        new_color = 30 * coin.pricebtc / (count * delta + v0)
        color.append(new_color)
        count += 1

    for count in range(1, 3650):
        date_now = date.today() + timedelta(count)
        values.append("")
        days += 1
        price3 = a3 * (days**b3)
        price2 = a2 * (days**b2)
        price1 = a1 * (days**b1)
        line3.append(price3)
        line2.append(price2)
        line1.append(price1)
        counter.append(days)
        if date_now.year > yearnumber:
            yearnumber += 1
            years.append(yearnumber)
            dates.append(days)

    now_price = "$" + locale.format("%.2f", now_price, grouping=True)
    now_sf = "$" + locale.format("%.2f", now_sf, grouping=True)
    maximum = "$" + locale.format("%.2f", maximum, grouping=True)
    now_inflation = locale.format("%.2f", now_inflation, grouping=True) + "%"

    context = {
        "values": values,
        "dates": dates,
        "maximum": maximum,
        "now_price": now_price,
        "now_inflation": now_inflation,
        "now_sf": now_sf,
        "color": color,
        "years": years,
        "counter": counter,
        "line1": line1,
        "line2": line2,
        "line3": line3,
    }
    return render(request, "charts/powerlaw.html", context)


def pricelin(request):
    symbol = "xmr"
    now_price = 0
    now_sf = 0
    now_inflation = 0
    v0 = 0.002
    delta = (0.015 - 0.002) / (6 * 365)
    count = 0
    maximum = 0
    supply = 0
    dates = []
    color = []
    values = []

    coins = Coin.objects.order_by("date").filter(name=symbol)
    for coin in coins:
        dates.append(datetime.datetime.strftime(coin.date, "%Y-%m-%d"))
        values.append(coin.priceusd)
        if coin.priceusd < 0.01:
            coin.priceusd = 0.01
        if coin.stocktoflow < 0.1:
            coin.stocktoflow = 0.1
        now_inflation = coin.inflation
        now_price = coin.priceusd
        now_sf = coin.stocktoflow
        if now_price > maximum:
            maximum = now_price
        new_color = 30 * coin.pricebtc / (count * delta + v0)
        color.append(new_color)
        supply = int(coin.supply) * 10**12
        count += 1

    count = 0
    for count in range(650):
        date_now = date.today() + timedelta(count)
        dates.append(datetime.datetime.strftime(date_now, "%Y-%m-%d"))
        reward = (2**64 - 1 - supply) >> 19
        if reward < 0.6 * (10**12):
            reward = 0.6 * (10**12)
        supply += int(720 * reward)
        stock = (
            100 / (100 * reward * 720 * 365 / supply)
        ) ** 1.65  # TODO: Seems unused... # noqa: F841

    now_price = "$" + locale.format("%.2f", now_price, grouping=True)
    now_sf = "$" + locale.format("%.2f", now_sf, grouping=True)
    maximum = "$" + locale.format("%.2f", maximum, grouping=True)
    now_inflation = locale.format("%.2f", now_inflation, grouping=True) + "%"

    context = {
        "values": values,
        "dates": dates,
        "maximum": maximum,
        "now_price": now_price,
        "now_inflation": now_inflation,
        "now_sf": now_sf,
        "color": color,
    }
    return render(request, "charts/pricelin.html", context)


def pricesats(request):
    dates = []
    color = []
    values = []
    now_price = 0
    maximum = 0
    bottom = 1

    data = Sfmodel.objects.order_by("date")
    for item in data:
        dates.append(datetime.datetime.strftime(item.date, "%Y-%m-%d"))
        if item.color != 0:
            color.append(item.color)
        else:
            color.append("")

        if item.pricebtc > 0.0001:
            values.append(item.pricebtc)
            now_price = item.pricebtc
            if bottom > item.pricebtc:
                bottom = item.pricebtc
            if maximum < item.pricebtc:
                maximum = item.pricebtc
        else:
            values.append("")

    now_price = locale.format("%.4f", now_price, grouping=True) + " BTC"
    maximum = locale.format("%.4f", maximum, grouping=True) + " BTC"
    bottom = locale.format("%.4f", bottom, grouping=True) + " BTC"

    context = {
        "values": values,
        "dates": dates,
        "maximum": maximum,
        "now_price": now_price,
        "color": color,
        "bottom": bottom,
    }
    return render(request, "charts/pricesats.html", context)


def pricesatslog(request):
    dates = []
    color = []
    values = []
    now_price = 0
    maximum = 0
    bottom = 1

    data = Sfmodel.objects.order_by("date")
    for item in data:
        dates.append(datetime.datetime.strftime(item.date, "%Y-%m-%d"))
        if item.color != 0:
            color.append(item.color)
        else:
            color.append("")

        if item.pricebtc > 0.0001:
            values.append(item.pricebtc)
            now_price = item.pricebtc
            if bottom > item.pricebtc:
                bottom = item.pricebtc
            if maximum < item.pricebtc:
                maximum = item.pricebtc
        else:
            values.append("")

    now_price = locale.format("%.4f", now_price, grouping=True) + " BTC"
    maximum = locale.format("%.4f", maximum, grouping=True) + " BTC"
    bottom = locale.format("%.4f", bottom, grouping=True) + " BTC"

    context = {
        "values": values,
        "dates": dates,
        "maximum": maximum,
        "now_price": now_price,
        "color": color,
        "bottom": bottom,
    }
    return render(request, "charts/pricesatslog.html", context)


def fractal(request):
    symbol = "xmr"
    dates1 = []
    dates2 = []
    cycle1 = []
    cycle2 = []
    now_multiple = 0
    maximum = 0

    count1 = 1
    count2 = 1
    date1_aux = datetime.datetime(2017, 12, 29)
    date2_aux = datetime.datetime(2014, 6, 21)
    coins = Coin.objects.order_by("date").filter(name=symbol)
    for coin in coins:
        date3_aux = datetime.datetime.combine(coin.date, datetime.time(0, 0))
        if date3_aux < date1_aux and date3_aux > date2_aux:
            cycle1.append(coin.priceusd / 5)
            dates1.append(count1 / 12.7)
            if (coin.priceusd / 5) > maximum:
                maximum = coin.priceusd / 5
            count1 += 1
        elif date3_aux > date1_aux:
            cycle2.append(coin.priceusd / 477.12)
            dates2.append(count2 / 20.7)  # 24
            now_multiple = coin.priceusd / 477.12
            count2 += 0.86

    now_multiple = locale.format("%.2f", now_multiple, grouping=True) + "x"
    maximum = locale.format("%.2f", maximum, grouping=True) + "x"

    context = {
        "cycle1": cycle1,
        "cycle2": cycle2,
        "dates1": dates1,
        "dates2": dates2,
        "now_multiple": now_multiple,
        "maximum": maximum,
    }
    return render(request, "charts/fractal.html", context)


def inflationfractal(request):
    symbol = "xmr"
    dates1 = []
    dates2 = []
    cycle1 = []
    cycle2 = []
    now_multiple = 0
    maximum = 0

    current_inflation = 0
    start_inflation = 0
    count1 = 1
    count2 = 1
    date1_aux = datetime.datetime(2017, 12, 29)
    date2_aux = datetime.datetime(2014, 6, 21)
    coins = Coin.objects.order_by("date").filter(name=symbol)
    for coin in coins:
        date3_aux = datetime.datetime.combine(coin.date, datetime.time(0, 0))
        if date3_aux < date1_aux and date3_aux > date2_aux:
            start_inflation = coin.inflation
            current_inflation = start_inflation
            cycle1.append(coin.priceusd / 5)
            dates1.append(count1 / 12.7)
            if (coin.priceusd / 5) > maximum:
                maximum = coin.priceusd / 5
            count1 += 1
        elif date3_aux > date1_aux:
            if (coin.inflation / current_inflation) > 1.15 or (
                coin.inflation / current_inflation
            ) < 0.85:
                coin.inflation = current_inflation
            else:
                current_inflation = coin.inflation
            delta = math.sqrt(coin.inflation / start_inflation)
            cycle2.append(delta * coin.priceusd / 477.12)
            dates2.append(count2 / 20.55)  # 24
            now_multiple = delta * coin.priceusd / 477.12
            count2 += 0.86

    now_multiple = locale.format("%.2f", now_multiple, grouping=True) + "x"
    maximum = locale.format("%.2f", maximum, grouping=True) + "x"

    context = {
        "cycle1": cycle1,
        "cycle2": cycle2,
        "dates1": dates1,
        "dates2": dates2,
        "now_multiple": now_multiple,
        "maximum": maximum,
    }
    return render(request, "charts/inflationfractal.html", context)


def golden(request):
    symbol = "xmr"
    dates = []
    prices = []

    coins = Coin.objects.order_by("date").filter(name=symbol)
    for coin in coins:
        firstdate = coin.date
        break

    day = firstdate - timedelta(350)
    for i in range(350):
        dates.append(datetime.datetime.strftime(day, "%Y-%m-%d"))
        prices.append(0.2)

    for coin in coins:
        dates.append(datetime.datetime.strftime(coin.date, "%Y-%m-%d"))
        if coin.priceusd > 0.2:
            prices.append(coin.priceusd)
        else:
            prices.append(0.2)

    n = 350
    median = pd.Series(prices).rolling(window=n).mean().iloc[n - 1 :].values
    m_350 = []
    m_350_0042 = []
    m_350_0060 = []
    m_350_0200 = []
    m_350_0300 = []
    m_350_0500 = []
    m_350_0800 = []
    m_350_1300 = []
    for i in range(350):
        m_350.append("")
        m_350_0042.append("")
        m_350_0060.append("")
        m_350_0200.append("")
        m_350_0300.append("")
        m_350_0500.append("")
        m_350_0800.append("")
        m_350_1300.append("")
    for item in median:
        m_350.append(float(item))
        m_350_0042.append(float(item) * 0.42)
        m_350_0060.append(float(item) * 0.60)
        m_350_0200.append(float(item) * 2.00)
        m_350_0300.append(float(item) * 3.00)
        m_350_0500.append(float(item) * 5.00)
        m_350_0800.append(float(item) * 8.00)
        m_350_1300.append(float(item) * 13.00)

    n = 120
    median = pd.Series(prices).rolling(window=n).mean().iloc[n - 1 :].values
    m_111 = []
    for i in range(120):
        m_111.append("")
    for item in median:
        m_111.append(float(item))

    i = 0
    down = True
    price_cross = []
    for price in prices:
        if m_111[i] != "" and m_350_0200[i] != "":
            if down and m_111[i] > m_350_0200[i]:
                down = False
                price_cross.append(price)
            elif price > m_350_0500[i]:
                price_cross.append(price)
            elif not down and m_111[i] < m_350_0200[i]:
                down = True
            else:
                price_cross.append("")
        else:
            price_cross.append("")
        i += 1

    context = {
        "dates": dates,
        "prices": prices,
        "m_350": m_350,
        "m_350_0042": m_350_0042,
        "m_350_0060": m_350_0060,
        "m_350_0200": m_350_0200,
        "m_350_0300": m_350_0300,
        "m_350_0500": m_350_0500,
        "m_350_0800": m_350_0800,
        "m_350_1300": m_350_1300,
        "median": median,
        "m_111": m_111,
        "price_cross": price_cross,
    }
    return render(request, "charts/golden.html", context)


def competitors(request):
    dates = []
    xmr = []
    dash = []
    grin = []
    zcash = []
    count = 0
    now_xmr = 0
    now_dash = 0
    now_grin = 0
    now_zcash = 0

    count = 0
    coins_xmr = Coin.objects.order_by("date").filter(name="xmr")
    for coin_xmr in coins_xmr:
        if coin_xmr.priceusd:
            if count > 30:
                xmr.append(coin_xmr.priceusd / 5.01)
                now_xmr = coin_xmr.priceusd / 5.01
            dates.append(count)
            count += 1
        elif count <= 63:
            continue
        else:
            xmr.append("")

    count = 0
    coins_dash = Coin.objects.order_by("date").filter(name="dash")
    for coin_dash in coins_dash:
        count += 1
        if coin_dash.priceusd and count > 130:
            dash.append(coin_dash.priceusd / 14.7)
            now_dash = coin_dash.priceusd / 14.7
        elif count <= 130:
            continue
        else:
            dash.append("")
        dates.append(count)

    count = 0
    coins_grin = Coin.objects.order_by("date").filter(name="grin")
    for coin_grin in coins_grin:
        count += 1
        if coin_grin.priceusd and count > 155:
            grin.append(coin_grin.priceusd / 6.37)
            now_grin = coin_grin.priceusd / 6.37
        elif count <= 155:
            continue
        else:
            grin.append("")
        dates.append(count)

    count = 0
    coins_zcash = Coin.objects.order_by("date").filter(name="zec")
    for coin_zcash in coins_zcash:
        count += 1
        if coin_zcash.priceusd and count > 434:
            zcash.append(coin_zcash.priceusd / 750)
            now_zcash = coin_zcash.priceusd / 750
        elif count <= 434:
            continue
        else:
            zcash.append("")
        dates.append(count)

    now_dash = locale.format("%.2f", now_dash, grouping=True)
    now_grin = locale.format("%.2f", now_grin, grouping=True)
    now_zcash = locale.format("%.2f", now_zcash, grouping=True)
    now_xmr = locale.format("%.2f", now_xmr, grouping=True)

    context = {
        "xmr": xmr,
        "dash": dash,
        "grin": grin,
        "zcash": zcash,
        "now_xmr": now_xmr,
        "now_dash": now_dash,
        "now_grin": now_grin,
        "now_zcash": now_zcash,
        "dates": dates,
    }
    return render(request, "charts/competitors.html", context)


def competitorslin(request):
    dates = []
    xmr = []
    dash = []
    grin = []
    zcash = []
    count = 0
    now_xmr = 0
    now_dash = 0
    now_grin = 0
    now_zcash = 0

    count = 0
    coins_xmr = Coin.objects.order_by("date").filter(name="xmr")
    for coin_xmr in coins_xmr:
        if coin_xmr.priceusd:
            if count > 30:
                xmr.append(coin_xmr.priceusd / 5.01)
                now_xmr = coin_xmr.priceusd / 5.01
            dates.append(count)
            count += 1
        elif count <= 63:
            continue
        else:
            xmr.append("")

    count = 0
    coins_dash = Coin.objects.order_by("date").filter(name="dash")
    for coin_dash in coins_dash:
        count += 1
        if coin_dash.priceusd and count > 130:
            dash.append(coin_dash.priceusd / 14.7)
            now_dash = coin_dash.priceusd / 14.7
        elif count <= 130:
            continue
        else:
            dash.append("")
        dates.append(count)

    count = 0
    coins_grin = Coin.objects.order_by("date").filter(name="grin")
    for coin_grin in coins_grin:
        count += 1
        if coin_grin.priceusd and count > 155:
            grin.append(coin_grin.priceusd / 6.37)
            now_grin = coin_grin.priceusd / 6.37
        elif count <= 155:
            continue
        else:
            grin.append("")
        dates.append(count)

    count = 0
    coins_zcash = Coin.objects.order_by("date").filter(name="zec")
    for coin_zcash in coins_zcash:
        count += 1
        if coin_zcash.priceusd and count > 434:
            zcash.append(coin_zcash.priceusd / 750)
            now_zcash = coin_zcash.priceusd / 750
        elif count <= 434:
            continue
        else:
            zcash.append("")
        dates.append(count)

    now_dash = locale.format("%.2f", now_dash, grouping=True)
    now_grin = locale.format("%.2f", now_grin, grouping=True)
    now_zcash = locale.format("%.2f", now_zcash, grouping=True)
    now_xmr = locale.format("%.2f", now_xmr, grouping=True)

    context = {
        "xmr": xmr,
        "dash": dash,
        "grin": grin,
        "zcash": zcash,
        "now_xmr": now_xmr,
        "now_dash": now_dash,
        "now_grin": now_grin,
        "now_zcash": now_zcash,
        "dates": dates,
    }
    return render(request, "charts/competitorslin.html", context)


def marketcap(request):
    data = DailyData.objects.order_by("date")

    dates = []
    xmr = []
    dash = []
    grin = []
    zcash = []
    now_xmr = 0
    now_dash = 0
    now_grin = 0
    now_zcash = 0

    for item in data:
        dates.append(datetime.datetime.strftime(item.date, "%Y-%m-%d"))

        if item.zcash_marketcap > 1000000:
            zcash.append(item.zcash_marketcap)
            now_zcash = item.zcash_marketcap
        else:
            zcash.append("")

        if item.dash_marketcap > 1000000:
            dash.append(item.dash_marketcap)
            now_dash = item.dash_marketcap
        else:
            dash.append("")

        if item.xmr_marketcap > 1000000:
            xmr.append(item.xmr_marketcap)
            now_xmr = item.xmr_marketcap
        else:
            xmr.append("")

        if item.grin_marketcap > 1000000:
            grin.append(item.grin_marketcap)
            now_grin = item.grin_marketcap
        else:
            grin.append("")

    now_dash = "$" + locale.format("%.0f", now_dash, grouping=True)
    now_grin = "$" + locale.format("%.0f", now_grin, grouping=True)
    now_zcash = "$" + locale.format("%.0f", now_zcash, grouping=True)
    now_xmr = "$" + locale.format("%.0f", now_xmr, grouping=True)

    context = {
        "xmr": xmr,
        "dash": dash,
        "grin": grin,
        "zcash": zcash,
        "now_xmr": now_xmr,
        "now_dash": now_dash,
        "now_grin": now_grin,
        "now_zcash": now_zcash,
        "dates": dates,
    }
    return render(request, "charts/marketcap.html", context)


def inflationreturn(request):
    count = 0
    xmr = []
    dash = []
    grin = []
    zcash = []
    btc = []
    now_xmr = 0
    now_dash = 0
    now_grin = 0
    now_zcash = 0
    now_btc = 0
    inflation_xmr = []
    inflation_dash = []
    inflation_grin = []
    inflation_zcash = []
    inflation_btc = []

    lastxmrA = 0
    lastxmrB = 0

    count = 0
    coins = Coin.objects.order_by("date").filter(name="xmr")
    for coin in coins:
        count += 1
        if coin.priceusd and count > 30 and coin.inflation > 0:
            now_xmr = coin.priceusd / 5.01
            # correcao de um erro nos dados
            if 100 / coin.inflation > 110 and now_xmr < 10:
                xmr.append(lastxmrA)
                inflation_xmr.append(lastxmrB)
            else:
                xmr.append(now_xmr)
                inflation_xmr.append(100 / coin.inflation)
                lastxmrA = now_xmr
                lastxmrB = 100 / coin.inflation

    count = 0
    coins = Coin.objects.order_by("date").filter(name="dash")
    for coin in coins:
        count += 1
        if coin.priceusd and count > 130 and coin.inflation > 0:
            now_dash = coin.priceusd / 14.7
            dash.append(now_dash)
            inflation_dash.append(100 / coin.inflation)

    count = 0
    coins = Coin.objects.order_by("date").filter(name="grin")
    for coin in coins:
        count += 1
        if coin.priceusd and count > 155 and coin.inflation > 0:
            now_grin = coin.priceusd / 6.37
            grin.append(now_grin)
            inflation_grin.append(100 / coin.inflation)

    count = 0
    coins = Coin.objects.order_by("date").filter(name="zec")
    for coin in coins:
        count += 1
        if coin.priceusd and count > 434 and coin.inflation > 0:
            now_zcash = coin.priceusd / 750
            zcash.append(now_zcash)
            inflation_zcash.append(100 / coin.inflation)

    count = 0
    coins = Coin.objects.order_by("date").filter(name="btc")
    for coin in coins:
        count += 1
        if coin.priceusd and count > 325 and coin.inflation > 0:
            now_btc = coin.priceusd / 30
            btc.append(now_btc)
            inflation_btc.append(100 / coin.inflation)

    now_dash = locale.format("%.2f", now_dash, grouping=True)
    now_grin = locale.format("%.2f", now_grin, grouping=True)
    now_zcash = locale.format("%.2f", now_zcash, grouping=True)
    now_xmr = locale.format("%.2f", now_xmr, grouping=True)
    now_btc = locale.format("%.2f", now_btc, grouping=True)

    context = {
        "inflation_btc": inflation_btc,
        "inflation_xmr": inflation_xmr,
        "inflation_dash": inflation_dash,
        "inflation_grin": inflation_grin,
        "inflation_zcash": inflation_zcash,
        "now_xmr": now_xmr,
        "now_dash": now_dash,
        "now_grin": now_grin,
        "now_zcash": now_zcash,
        "now_btc": now_btc,
        "btc": btc,
        "xmr": xmr,
        "dash": dash,
        "zcash": zcash,
        "grin": grin,
    }
    return render(request, "charts/inflationreturn.html", context)


def bitcoin(request):
    dates = []
    dates3 = []
    dates4 = []
    btc = []
    xmr3 = []
    count1 = 0
    count3 = 0
    now_xmr = 0
    now_btc = 0

    coins_btc = Coin.objects.order_by("date").filter(name="btc")
    for coin_btc in coins_btc:
        if coin_btc.priceusd:
            if count1 > 890:  # 450
                btc.append(coin_btc.priceusd / 30)
                now_btc = coin_btc.priceusd / 30
            dates.append(count1)
            count1 += 1  # 1.4
        elif count1 <= 890:  # 450
            continue
        else:
            btc.append("")

    coins_xmr = Coin.objects.order_by("date").filter(name="xmr")

    for coin_xmr in coins_xmr:
        if coin_xmr.priceusd:
            if count3 > 30:
                xmr3.append(coin_xmr.priceusd / 5.01)
            dates4.append(count3)
            count3 += 0.92
        elif count3 <= 30:
            continue
        else:
            xmr3.append("")

    data = DailyData.objects.order_by("date")

    dates2 = []
    xmr2 = []
    btc2 = []

    for item in data:
        dates2.append(datetime.datetime.strftime(item.date, "%Y-%m-%d"))

        if item.btc_return > 0.0001:
            btc2.append(item.btc_return)
        else:
            btc2.append("")

        if item.xmr_return > 0.0001:
            xmr2.append(item.xmr_return)
        else:
            xmr2.append("")

    now_btc = locale.format("%.2f", now_btc, grouping=True)
    now_xmr = locale.format("%.2f", now_xmr, grouping=True)

    context = {
        "btc": btc,
        "xmr2": xmr2,
        "btc2": btc2,
        "xmr3": xmr3,
        "dates": dates,
        "dates2": dates2,
        "dates3": dates3,
        "dates4": dates4,
    }
    return render(request, "charts/bitcoin.html", context)


def translin(request):
    symbol = "xmr"
    transactions = []
    pricexmr = []
    dates = []
    now_transactions = 0
    maximum = 0

    coins = Coin.objects.order_by("date")
    for coin in coins:
        print(str(coin.name) + "    " + str(coin.date))
    coins = Coin.objects.order_by("date").filter(name=symbol)
    for coin in coins:
        if coin.transactions > 200:
            transactions.append(coin.transactions)
            now_transactions = coin.transactions
            if now_transactions > maximum:
                maximum = now_transactions
        else:
            transactions.append("")

        if coin.priceusd > 0.001:
            pricexmr.append(coin.priceusd)
        else:
            pricexmr.append("")

        coin.date = datetime.datetime.strftime(coin.date, "%Y-%m-%d")
        dates.append(coin.date)

    now_transactions = int(now_transactions)
    maximum = int(maximum)

    context = {
        "transactions": transactions,
        "dates": dates,
        "maximum": maximum,
        "now_transactions": now_transactions,
        "pricexmr": pricexmr,
    }
    return render(request, "charts/translin.html", context)


def transmonth(request):
    symbol = "xmr"
    transactions = []
    pricexmr = []
    dates = []
    now_transactions = 0
    maximum = 0

    month_previous = "2014-01"
    month = 0
    total = 0
    coins = Coin.objects.order_by("date").filter(name=symbol)
    for coin in coins:
        aux = str(coin.date)
        month = aux.split("-")[0] + "-" + aux.split("-")[1]
        if month != month_previous:
            dates.append(month_previous)
            transactions.append(total)
            if total > maximum:
                maximum = total
            total = 0
            month_previous = month

        if coin.transactions > 0:
            total += coin.transactions

    now_transactions = int(total)
    maximum = int(maximum)

    now_transactions = locale.format("%.0f", now_transactions, grouping=True)
    maximum = locale.format("%.0f", maximum, grouping=True)

    context = {
        "transactions": transactions,
        "dates": dates,
        "maximum": maximum,
        "now_transactions": now_transactions,
        "pricexmr": pricexmr,
    }
    return render(request, "charts/transmonth.html", context)


def percentmonth(request):
    symbol = "xmr"
    transactions = []
    pricexmr = []
    dates = []
    now_transactions = 0
    maximum = 0

    month_previous = "2014-01"
    month = 0
    total = 0
    total_btc = 0
    total_xmr = 0
    coins = Coin.objects.order_by("date").filter(name=symbol)
    for coin in coins:
        aux = str(coin.date)
        month = aux.split("-")[0] + "-" + aux.split("-")[1]
        try:
            coin_btc = Coin.objects.filter(name="btc").get(date=coin.date)
        except Coin.DoesNotExist:
            pass
        if month != month_previous:
            dates.append(month_previous)
            if total_btc > 0:
                total = 100 * total_xmr / total_btc
            else:
                total = 0
            transactions.append(total)
            if total > maximum:
                maximum = total
            total_xmr = 0
            total_btc = 0
            month_previous = month

        if coin.transactions > 0:
            total_xmr += coin.transactions
        if coin_btc.transactions > 0:
            total_btc += coin_btc.transactions

    if total_btc > 0:
        total = 100 * total_xmr / total_btc
    else:
        total = 0

    now_transactions = locale.format("%.1f", total, grouping=True) + " %"
    maximum = locale.format("%.1f", maximum, grouping=True) + " %"

    context = {
        "transactions": transactions,
        "dates": dates,
        "maximum": maximum,
        "now_transactions": now_transactions,
        "pricexmr": pricexmr,
    }
    return render(request, "charts/percentmonth.html", context)


def deviation(request):
    symbol = "xmr"
    pricexmr = []
    dates = []

    coins = Coin.objects.order_by("date").filter(name=symbol)
    for coin in coins:
        if coin.priceusd > 0.001:
            pricexmr.append(coin.priceusd)
        else:
            pricexmr.append(0.20)

        coin.date = datetime.datetime.strftime(coin.date, "%Y-%m-%d")
        dates.append(coin.date)

    n = 180
    median_long_price = (
        pd.Series(pricexmr).rolling(window=n).mean().iloc[n - 1 :].values
    )
    m_long_price = []
    for i in range(n):
        m_long_price.append(0)
    for item in median_long_price:
        m_long_price.append(float(item))

    n = 3
    median_short_price = (
        pd.Series(pricexmr).rolling(window=n).mean().iloc[n - 1 :].values
    )
    m_short_price = []
    for i in range(n):
        m_short_price.append(0)
    for item in median_short_price:
        m_short_price.append(float(item))

    deviation_percentage = []
    deviation_price = []
    for count in range(0, len(m_short_price)):
        if float(m_long_price[count]) < 0.001:
            deviation_price.append("")
            deviation_percentage.append("")
        else:
            deviation_price.append(
                (float(m_short_price[count]) - float(m_long_price[count])) / (1)
            )
            deviation_percentage.append(
                100
                * (float(m_short_price[count]) - float(m_long_price[count]))
                / (float(m_long_price[count]))
            )

    context = {
        "deviation_percentage": deviation_percentage,
        "deviation_price": deviation_price,
        "dates": dates,
        "pricexmr": pricexmr,
    }
    return render(request, "charts/deviation.html", context)


def deviation_tx(request):
    symbol = "xmr"
    transactions = []
    pricexmr = []
    dates = []

    coins = Coin.objects.order_by("date").filter(name=symbol)
    for coin in coins:
        transactions.append(coin.transactions)
        if coin.priceusd > 0.001:
            pricexmr.append(coin.priceusd)
        else:
            pricexmr.append(0.20)

        coin.date = datetime.datetime.strftime(coin.date, "%Y-%m-%d")
        dates.append(coin.date)

    n = 180
    median_long = pd.Series(transactions).rolling(window=n).mean().iloc[n - 1 :].values
    m_long = []
    for i in range(n):
        m_long.append(0)
    for item in median_long:
        m_long.append(float(item))

    n = 3
    median_short = pd.Series(transactions).rolling(window=n).mean().iloc[n - 1 :].values
    m_short = []
    for i in range(n):
        m_short.append(0)
    for item in median_short:
        m_short.append(float(item))

    n = 180
    median_long_price = (
        pd.Series(pricexmr).rolling(window=n).mean().iloc[n - 1 :].values
    )
    m_long_price = []
    for i in range(n):
        m_long_price.append(0)
    for item in median_long_price:
        m_long_price.append(float(item))

    n = 3
    median_short_price = (
        pd.Series(pricexmr).rolling(window=n).mean().iloc[n - 1 :].values
    )
    m_short_price = []
    for i in range(n):
        m_short_price.append(0)
    for item in median_short_price:
        m_short_price.append(float(item))

    deviation_percentage = []
    for count in range(0, len(m_short)):
        if float(m_long[count]) < 0.001 or float(m_long_price[count]) < 0.001:
            deviation_percentage.append("")
        else:
            calculation = (
                (float(m_short_price[count]) - float(m_long_price[count]))
                * abs(float(m_short[count]) - float(m_long[count]))
                / (float(m_long[count]))
            )
            if calculation > 100:
                calculation = 100
            if calculation < -100:
                calculation = -100
            deviation_percentage.append(calculation)

    context = {
        "deviation_percentage": deviation_percentage,
        "dates": dates,
        "pricexmr": pricexmr,
    }
    return render(request, "charts/deviation_tx.html", context)


def percentage(request):
    data = DailyData.objects.order_by("date")

    transactions = []
    dates = []
    now_transactions = 0
    maximum = 0

    for item in data:
        dates.append(datetime.datetime.strftime(item.date, "%Y-%m-%d"))
        if item.xmr_transacpercentage > 0.00001:
            transactions.append(100 * item.xmr_transacpercentage)
            now_transactions = 100 * item.xmr_transacpercentage
            if now_transactions > maximum:
                maximum = now_transactions
        else:
            transactions.append("")

    now_transactions = locale.format("%.1f", now_transactions, grouping=True) + "%"
    maximum = locale.format("%.1f", maximum, grouping=True) + "%"

    context = {
        "transactions": transactions,
        "dates": dates,
        "now_transactions": now_transactions,
        "maximum": maximum,
    }
    return render(request, "charts/percentage.html", context)


def translog(request):
    symbol = "xmr"
    transactions = []
    pricexmr = []
    dates = []
    now_transactions = 0
    maximum = 0

    coins = Coin.objects.order_by("date").filter(name=symbol)
    for coin in coins:
        if coin.transactions > 200:
            transactions.append(coin.transactions)
            now_transactions = coin.transactions
            if now_transactions > maximum:
                maximum = now_transactions
        else:
            transactions.append("")

        if coin.priceusd > 0.001:
            pricexmr.append(coin.priceusd)
        else:
            pricexmr.append("")

        coin.date = datetime.datetime.strftime(coin.date, "%Y-%m-%d")
        dates.append(coin.date)

    now_transactions = int(now_transactions)
    maximum = int(maximum)

    context = {
        "transactions": transactions,
        "dates": dates,
        "maximum": maximum,
        "now_transactions": now_transactions,
        "pricexmr": pricexmr,
    }
    return render(request, "charts/translog.html", context)


def hashrate(request):
    symbol = "xmr"
    hashrate = []
    dates = []
    now_hashrate = 0

    coins = Coin.objects.order_by("date").filter(name=symbol)
    for coin in coins:
        coin.date = datetime.datetime.strftime(coin.date, "%Y-%m-%d")
        dates.append(coin.date)
        if coin.hashrate > 0:
            now_hashrate = coin.hashrate
            hashrate.append(coin.hashrate)
        else:
            hashrate.append("")

    now_hashrate = locale.format("%.0f", now_hashrate, grouping=True)

    context = {"hashrate": hashrate, "dates": dates, "now_hashrate": now_hashrate}
    return render(request, "charts/hashrate.html", context)


def hashprice(request):
    symbol = "xmr"
    hashrate = []
    dates = []
    buy = []
    sell = []
    now_hashrate = 0
    color = []
    v0 = 0.002
    delta = (0.015 - 0.002) / (6 * 365)
    count = 0

    coins = Coin.objects.order_by("date").filter(name=symbol)
    for coin in coins:
        if count > 50:
            buy.append(0.00000003)
            sell.append(0.00000100)
            coin.date = datetime.datetime.strftime(coin.date, "%Y-%m-%d")
            dates.append(coin.date)
            if coin.hashrate > 0 and coin.priceusd > 0:
                now_hashrate = coin.priceusd / coin.hashrate
                hashrate.append(now_hashrate)
            else:
                hashrate.append("")
            new_color = 30 * coin.pricebtc / (count * delta + v0)
            color.append(new_color)
        count += 1

    now_hashrate = locale.format("%.8f", now_hashrate, grouping=True)

    context = {
        "hashrate": hashrate,
        "dates": dates,
        "now_hashrate": now_hashrate,
        "color": color,
        "buy": buy,
        "sell": sell,
    }
    return render(request, "charts/hashprice.html", context)


def hashvsprice(request):
    symbol = "xmr"
    hashrate = []
    prices = []
    dates = []
    now_hashrate = 0
    now_priceusd = 0
    now_pricebtc = 0
    color = []
    v0 = 0.002
    delta = (0.015 - 0.002) / (6 * 365)
    count = 0

    coins = Coin.objects.order_by("date").filter(name=symbol)
    for coin in coins:
        if count > 55:
            coin.date = datetime.datetime.strftime(coin.date, "%Y-%m-%d")
            dates.append(coin.date)
            if coin.priceusd > 0 and coin.hashrate:
                now_hashrate = coin.hashrate
                now_priceusd = coin.priceusd
                now_pricebtc = coin.pricebtc
                hashrate.append(now_hashrate)
                prices.append(now_priceusd)
            else:
                hashrate.append("")
                prices.append("")
            new_color = 30 * coin.pricebtc / (count * delta + v0)
            color.append(new_color)
        count += 1

    now_hashrate = locale.format("%.0f", now_hashrate, grouping=True)
    now_priceusd = "$" + locale.format("%.2f", now_priceusd, grouping=True)
    now_pricebtc = locale.format("%.5f", now_pricebtc, grouping=True) + " BTC"

    context = {
        "hashrate": hashrate,
        "dates": dates,
        "now_hashrate": now_hashrate,
        "color": color,
        "prices": prices,
        "now_pricebtc": now_pricebtc,
        "now_priceusd": now_priceusd,
    }
    return render(request, "charts/hashvsprice.html", context)


def metcalfesats(request):
    data = DailyData.objects.order_by("date")

    color = []
    metcalfe = []
    prices = []
    dates = []
    now_metcalfe = 0
    now_price = 0
    maximum = 0
    v0 = 0.002
    delta = (0.015 - 0.002) / (6 * 365)
    count = 0

    for item in data:
        dates.append(datetime.datetime.strftime(item.date, "%Y-%m-%d"))
        if item.xmr_metcalfebtc < 0.0007:
            metcalfe.append("")
            color.append("")
            prices.append("")
        else:
            metcalfe.append(item.xmr_metcalfebtc)
            now_price = item.xmr_pricebtc
            now_metcalfe = item.xmr_metcalfebtc
            if now_metcalfe > maximum:
                maximum = now_metcalfe
            color.append(30 * item.xmr_pricebtc / (count * delta + v0))
            prices.append(now_price)
            count += 1

    now_price = locale.format("%.4f", now_price, grouping=True) + " BTC"
    now_metcalfe = locale.format("%.4f", now_metcalfe, grouping=True) + " BTC"
    maximum = locale.format("%.4f", maximum, grouping=True) + " BTC"

    context = {
        "metcalfe": metcalfe,
        "dates": dates,
        "maximum": maximum,
        "now_metcalfe": now_metcalfe,
        "color": color,
        "prices": prices,
        "now_price": now_price,
    }
    return render(request, "charts/metcalfesats.html", context)


def metcalfesats_deviation(request):
    data = DailyData.objects.order_by("date")

    metcalfe_percentage = []
    metcalfe = []
    dates = []
    now_metcalfe = 0
    now_metcalfe_percentage = 0

    for item in data:
        dates.append(datetime.datetime.strftime(item.date, "%Y-%m-%d"))
        if item.xmr_metcalfebtc < 0.0007 and item.xmr_pricebtc <= 0:
            metcalfe.append("")
            metcalfe_percentage.append("")
        else:
            now_metcalfe = item.xmr_metcalfebtc - item.xmr_pricebtc
            now_metcalfe_percentage = 100 * (
                (item.xmr_metcalfebtc / item.xmr_pricebtc) - 1
            )
            metcalfe.append(now_metcalfe)
            metcalfe_percentage.append(now_metcalfe_percentage)

    now_metcalfe = locale.format("%.4f", now_metcalfe, grouping=True)
    now_metcalfe_percentage = locale.format(
        "%.0f", now_metcalfe_percentage, grouping=True
    )

    context = {
        "metcalfe": metcalfe,
        "dates": dates,
        "now_metcalfe": now_metcalfe,
        "now_metcalfe_percentage": now_metcalfe_percentage,
        "metcalfe_percentage": metcalfe_percentage,
    }
    return render(request, "charts/metcalfesats_deviation.html", context)


def metcalfe_deviation(request):
    data = DailyData.objects.order_by("date")

    metcalfe_percentage = []
    metcalfe = []
    dates = []
    now_metcalfe = 0
    now_metcalfe_percentage = 0

    for item in data:
        dates.append(datetime.datetime.strftime(item.date, "%Y-%m-%d"))
        if item.xmr_metcalfeusd < 0.0007 and item.xmr_priceusd <= 0:
            metcalfe.append("")
            metcalfe_percentage.append("")
        else:
            now_metcalfe = item.xmr_metcalfeusd - item.xmr_priceusd
            now_metcalfe_percentage = 100 * (
                (item.xmr_metcalfeusd / item.xmr_priceusd) - 1
            )
            metcalfe.append(now_metcalfe)
            metcalfe_percentage.append(now_metcalfe_percentage)

    now_metcalfe = locale.format("%.0f", now_metcalfe, grouping=True)
    now_metcalfe_percentage = locale.format(
        "%.0f", now_metcalfe_percentage, grouping=True
    )

    context = {
        "metcalfe": metcalfe,
        "dates": dates,
        "now_metcalfe": now_metcalfe,
        "now_metcalfe_percentage": now_metcalfe_percentage,
        "metcalfe_percentage": metcalfe_percentage,
    }
    return render(request, "charts/metcalfe_deviation.html", context)


def metcalfeusd(request):
    data = DailyData.objects.order_by("date")

    color = []
    metcalfe = []
    prices = []
    dates = []
    now_metcalfe = 0
    now_price = 0
    maximum = 0
    v0 = 0.002
    delta = (0.015 - 0.002) / (6 * 365)
    count = 0

    for item in data:
        dates.append(datetime.datetime.strftime(item.date, "%Y-%m-%d"))
        if item.xmr_metcalfeusd < 0.001:
            metcalfe.append("")
            color.append("")
            prices.append("")
        else:
            metcalfe.append(item.xmr_metcalfeusd)
            now_price = item.xmr_priceusd
            now_metcalfe = item.xmr_metcalfeusd
            if now_metcalfe > maximum:
                maximum = now_metcalfe
            color.append(30 * item.xmr_pricebtc / (count * delta + v0))
            prices.append(now_price)
            count += 1

    now_price = "$" + locale.format("%.2f", now_price, grouping=True)
    now_metcalfe = "$" + locale.format("%.2f", now_metcalfe, grouping=True)
    maximum = "$" + locale.format("%.2f", maximum, grouping=True)

    context = {
        "metcalfe": metcalfe,
        "dates": dates,
        "maximum": maximum,
        "now_metcalfe": now_metcalfe,
        "color": color,
        "prices": prices,
        "now_price": now_price,
    }
    return render(request, "charts/metcalfeusd.html", context)


def coins(request):
    data = DailyData.objects.order_by("date")

    supplyxmr = []
    supplybtc = []
    fsupplyxmr = []
    fsupplybtc = []
    dates = []
    now_xmr = 0
    now_btc = 0

    for item in data:
        dates.append(datetime.datetime.strftime(item.date, "%Y-%m-%d"))

        if item.btc_supply > 0.1:
            supplybtc.append(item.btc_supply)
            now_btc = item.btc_supply
        else:
            supplybtc.append("")

        if item.xmr_inflation > 0.1:
            supplyxmr.append(item.xmr_supply)
            now_xmr = item.xmr_supply
        else:
            supplyxmr.append("")

        fsupplyxmr.append("")
        fsupplybtc.append("")

    rewardbtc = 900
    supplybitcoin = item.btc_supply
    supply = int(item.xmr_supply) * 10**12
    for i in range(365 * (2060 - 2020)):
        supply = int(supply)
        reward = (2**64 - 1 - supply) >> 19
        if reward < 0.6 * (10**12):
            reward = 0.6 * (10**12)
        supply += int(720 * reward)
        fsupplyxmr.append(supply / (10**12))
        date_aux = item.date + timedelta(i)
        dates.append(datetime.datetime.strftime(date_aux, "%Y-%m-%d"))
        supplybitcoin += rewardbtc
        if supplybitcoin > 21000000:
            supplybitcoin = 21000000
        fsupplybtc.append(supplybitcoin)
        date_aux2 = datetime.datetime.strftime(date_aux, "%Y-%m-%d")
        if date_aux2 == "2024-04-23":
            rewardbtc = rewardbtc / 2
        if date_aux2 == "2028-05-05":
            rewardbtc = rewardbtc / 2
        if date_aux2 == "2032-05-03":
            rewardbtc = rewardbtc / 2
        if date_aux2 == "2036-04-30":
            rewardbtc = rewardbtc / 2
        if date_aux2 == "2040-04-27":
            rewardbtc = rewardbtc / 2
        if date_aux2 == "2044-04-25":
            rewardbtc = rewardbtc / 2
        if date_aux2 == "2048-04-22":
            rewardbtc = rewardbtc / 2
        if date_aux2 == "2052-04-19":
            rewardbtc = rewardbtc / 2
        if date_aux2 == "2056-04-30":
            rewardbtc = rewardbtc / 2
        if date_aux2 == "2060-04-27":
            rewardbtc = rewardbtc / 2
        if date_aux2 == "2064-04-25":
            rewardbtc = rewardbtc / 2
        if date_aux2 == "2068-04-22":
            rewardbtc = rewardbtc / 2
        if date_aux2 == "2072-04-19":
            rewardbtc = rewardbtc / 2
        if date_aux2 == "2076-04-30":
            rewardbtc = rewardbtc / 2
        if date_aux2 == "2080-04-27":
            rewardbtc = rewardbtc / 2
        if date_aux2 == "2084-04-25":
            rewardbtc = rewardbtc / 2
        if date_aux2 == "2088-04-22":
            rewardbtc = rewardbtc / 2
        if date_aux2 == "2140-01-01":
            rewardbtc = 0
            supplybitcoin = 21000000
        supplyxmr.append("")
        supplybtc.append("")

    now_btc = locale.format("%.0f", now_btc, grouping=True)
    now_xmr = locale.format("%.0f", now_xmr, grouping=True)

    context = {
        "supplyxmr": supplyxmr,
        "supplybtc": supplybtc,
        "fsupplyxmr": fsupplyxmr,
        "fsupplybtc": fsupplybtc,
        "now_xmr": now_xmr,
        "now_btc": now_btc,
        "dates": dates,
    }
    return render(request, "charts/coins.html", context)


def dailyemission(request):
    data = DailyData.objects.order_by("date")

    emissionbtc = []
    emissionxmr = []
    dates = []
    now_btc = 0
    now_xmr = 0
    high_btc = 0
    high_xmr = 0

    for item in data:
        if item.btc_emissionusd == 0:
            emissionbtc.append("")
        else:
            emissionbtc.append(item.btc_emissionusd)
            now_btc = item.btc_emissionusd
            if item.btc_emissionusd > high_btc:
                high_btc = item.btc_emissionusd

        if item.xmr_emissionusd == 0:
            emissionxmr.append("")
        else:
            emissionxmr.append(item.xmr_emissionusd)
            now_xmr = item.xmr_emissionusd
            if item.xmr_emissionusd > high_xmr:
                high_xmr = item.xmr_emissionusd
        dates.append(datetime.datetime.strftime(item.date, "%Y-%m-%d"))

    for i in range(500):
        date_aux = item.date + timedelta(i)
        dates.append(datetime.datetime.strftime(date_aux, "%Y-%m-%d"))
        emissionxmr.append("")
        emissionbtc.append("")

    now_btc = "$" + locale.format("%.0f", now_btc, grouping=True)
    now_xmr = "$" + locale.format("%.0f", now_xmr, grouping=True)
    high_btc = "$" + locale.format("%.0f", high_btc, grouping=True)
    high_xmr = "$" + locale.format("%.0f", high_xmr, grouping=True)

    context = {
        "emissionxmr": emissionxmr,
        "emissionbtc": emissionbtc,
        "high_xmr": high_xmr,
        "high_btc": high_btc,
        "now_xmr": now_xmr,
        "now_btc": now_btc,
        "dates": dates,
    }
    return render(request, "charts/dailyemission.html", context)


def extracoins(request):
    data = DailyData.objects.order_by("date")

    nsupply = []
    fsupply = []
    dates = []
    now_diff = 0

    for item in data:
        dates.append(datetime.datetime.strftime(item.date, "%Y-%m-%d"))

        if item.btc_supply - item.xmr_supply > 0:
            nsupply.append(item.btc_supply - item.xmr_supply)
        else:
            nsupply.append("")

        fsupply.append("")

    rewardbtc = 900
    supplybitcoin = item.btc_supply
    supply = int(item.xmr_supply) * 10**12
    for i in range(365 * (2060 - 2020)):
        supply = int(supply)
        reward = (2**64 - 1 - supply) >> 19
        if reward < 0.6 * (10**12):
            reward = 0.6 * (10**12)
        supply += int(720 * reward)
        date_aux = item.date + timedelta(i)
        dates.append(datetime.datetime.strftime(date_aux, "%Y-%m-%d"))
        supplybitcoin += rewardbtc
        if supplybitcoin > 21000000:
            supplybitcoin = 21000000
        fsupply.append(-supply / (10**12) + supplybitcoin)
        date_aux2 = datetime.datetime.strftime(date_aux, "%Y-%m-%d")
        if date_aux2 == "2024-04-23":
            rewardbtc = rewardbtc / 2
        if date_aux2 == "2028-05-05":
            rewardbtc = rewardbtc / 2
        if date_aux2 == "2032-05-03":
            rewardbtc = rewardbtc / 2
        if date_aux2 == "2036-04-30":
            rewardbtc = rewardbtc / 2
        if date_aux2 == "2040-04-27":
            rewardbtc = rewardbtc / 2
        if date_aux2 == "2044-04-25":
            rewardbtc = rewardbtc / 2
        if date_aux2 == "2048-04-22":
            rewardbtc = rewardbtc / 2
        if date_aux2 == "2052-04-19":
            rewardbtc = rewardbtc / 2
        if date_aux2 == "2056-04-30":
            rewardbtc = rewardbtc / 2
        if date_aux2 == "2060-04-27":
            rewardbtc = rewardbtc / 2
        if date_aux2 == "2064-04-25":
            rewardbtc = rewardbtc / 2
        if date_aux2 == "2068-04-22":
            rewardbtc = rewardbtc / 2
        if date_aux2 == "2072-04-19":
            rewardbtc = rewardbtc / 2
        if date_aux2 == "2076-04-30":
            rewardbtc = rewardbtc / 2
        if date_aux2 == "2080-04-27":
            rewardbtc = rewardbtc / 2
        if date_aux2 == "2084-04-25":
            rewardbtc = rewardbtc / 2
        if date_aux2 == "2088-04-22":
            rewardbtc = rewardbtc / 2
        if date_aux2 == "2140-01-01":
            rewardbtc = 0
            supplybitcoin = 21000000
        nsupply.append("")

    now_diff = locale.format("%.0f", now_diff, grouping=True)

    context = {
        "nsupply": nsupply,
        "fsupply": fsupply,
        "dates": dates,
        "now_diff": now_diff,
    }
    return render(request, "charts/extracoins.html", context)


def inflation(request):
    data = DailyData.objects.order_by("date")

    inflationxmr = []
    inflationbtc = []
    finflationxmr = []
    finflationbtc = []
    dates = []
    now_xmr = 999999
    now_btc = 999999

    for item in data:
        dates.append(datetime.datetime.strftime(item.date, "%Y-%m-%d"))

        if item.btc_inflation > 0.1:
            inflationbtc.append(item.btc_inflation)
            now_btc = item.btc_inflation
        else:
            inflationbtc.append("")

        if item.xmr_inflation > 0.1:
            inflationxmr.append(item.xmr_inflation)
            now_xmr = item.xmr_inflation
        else:
            inflationxmr.append("")

        finflationxmr.append("")
        finflationbtc.append("")

    inflationbitcoin = 1.75
    supply = int(item.xmr_supply) * 10**12
    for i in range(2000):
        supply = int(supply)
        reward = (2**64 - 1 - supply) >> 19
        if reward < 0.6 * (10**12):
            reward = 0.6 * (10**12)
        supply += int(720 * reward)
        finflationxmr.append(100 * reward * 720 * 365 / supply)
        date_aux = item.date + timedelta(i)
        dates.append(datetime.datetime.strftime(date_aux, "%Y-%m-%d"))
        finflationbtc.append(inflationbitcoin)
        date_aux2 = datetime.datetime.strftime(date_aux, "%Y-%m-%d")
        if date_aux2 == "2024-04-23":
            inflationbitcoin = 0.65
        inflationxmr.append("")
        inflationbtc.append("")

    now_btc = locale.format("%.2f", now_btc, grouping=True) + "%"
    now_xmr = locale.format("%.2f", now_xmr, grouping=True) + "%"

    context = {
        "inflationxmr": inflationxmr,
        "inflationbtc": inflationbtc,
        "finflationxmr": finflationxmr,
        "finflationbtc": finflationbtc,
        "now_xmr": now_xmr,
        "now_btc": now_btc,
        "dates": dates,
    }
    return render(request, "charts/inflation.html", context)


def blocksize(request):
    data = DailyData.objects.order_by("date")

    xmr_blocksize = []
    btc_blocksize = []
    dates = []
    now_xmr = 0
    now_btc = 0

    for item in data:
        dates.append(datetime.datetime.strftime(item.date, "%Y-%m-%d"))
        if item.btc_blocksize > 0.001:
            btc_blocksize.append(item.btc_blocksize / 1024)
            now_btc = item.btc_blocksize
        else:
            btc_blocksize.append("")

        if item.xmr_blocksize > 0.001:
            xmr_blocksize.append(item.xmr_blocksize / 1024)
            now_xmr = item.xmr_blocksize
        else:
            xmr_blocksize.append("")

    now_btc = locale.format("%.2f", now_btc, grouping=True) + " bytes"
    now_xmr = locale.format("%.2f", now_xmr, grouping=True) + " bytes"

    context = {
        "xmr_blocksize": xmr_blocksize,
        "btc_blocksize": btc_blocksize,
        "now_xmr": now_xmr,
        "now_btc": now_btc,
        "dates": dates,
    }
    return render(request, "charts/blocksize.html", context)


def transactionsize(request):
    data = DailyData.objects.order_by("date")

    xmr_blocksize = []
    btc_blocksize = []
    dates = []
    now_xmr = 0
    now_btc = 0

    for item in data:
        dates.append(datetime.datetime.strftime(item.date, "%Y-%m-%d"))

        if item.btc_blocksize > 0.001 and item.btc_transactions > 0:
            now_btc = 144 * item.btc_blocksize / (1024 * item.btc_transactions)
            btc_blocksize.append(
                144 * item.btc_blocksize / (1024 * item.btc_transactions)
            )
        else:
            btc_blocksize.append("")

        if item.xmr_blocksize > 0.001 and item.xmr_transactions > 0:
            now_xmr = 720 * item.xmr_blocksize / (1024 * item.xmr_transactions)
            xmr_blocksize.append(
                720 * item.xmr_blocksize / (1024 * item.xmr_transactions)
            )
        else:
            xmr_blocksize.append("")

    now_btc = locale.format("%.2f", now_btc, grouping=True) + " bytes"
    now_xmr = locale.format("%.2f", now_xmr, grouping=True) + " bytes"

    context = {
        "xmr_blocksize": xmr_blocksize,
        "btc_blocksize": btc_blocksize,
        "now_xmr": now_xmr,
        "now_btc": now_btc,
        "dates": dates,
    }
    return render(request, "charts/transactionsize.html", context)


def transactiondominance(request):
    data = DailyData.objects.order_by("date")

    xmr_dominance = []
    dates = []
    now_xmr = 0
    maximum = 0

    for item in data:
        dates.append(datetime.datetime.strftime(item.date, "%Y-%m-%d"))
        if item.xmr_transactions > 0:
            now_xmr = (
                100
                * item.xmr_transactions
                / (
                    item.xmr_transactions
                    + item.dash_transactions
                    + item.zcash_transactions
                    + item.grin_transactions
                )
            )
        else:
            now_xmr = 0
        if now_xmr > maximum:
            maximum = now_xmr
        xmr_dominance.append(now_xmr)

    now_xmr = locale.format("%.1f", now_xmr, grouping=True) + "%"
    maximum = locale.format("%.1f", maximum, grouping=True) + "%"

    context = {
        "xmr_dominance": xmr_dominance,
        "now_xmr": now_xmr,
        "maximum": maximum,
        "dates": dates,
    }
    return render(request, "charts/transactiondominance.html", context)


def difficulty(request):
    data = DailyData.objects.order_by("date")

    xmr_difficulty = []
    btc_difficulty = []
    dates = []
    now_xmr = 0
    now_btc = 0

    for item in data:
        dates.append(datetime.datetime.strftime(item.date, "%Y-%m-%d"))

        if item.btc_difficulty > 0.001:
            now_btc = item.btc_difficulty
            btc_difficulty.append(now_btc)
        else:
            btc_difficulty.append("")

        if item.xmr_difficulty > 0.001:
            now_xmr = item.xmr_difficulty
            xmr_difficulty.append(now_xmr)
        else:
            xmr_difficulty.append("")

    now_btc = locale.format("%.0f", now_btc, grouping=True)
    now_xmr = locale.format("%.0f", now_xmr, grouping=True)

    context = {
        "xmr_difficulty": xmr_difficulty,
        "btc_difficulty": btc_difficulty,
        "now_xmr": now_xmr,
        "now_btc": now_btc,
        "dates": dates,
    }
    return render(request, "charts/difficulty.html", context)


def blockchainsize(request):
    data = DailyData.objects.order_by("date")

    xmr_blocksize = []
    btc_blocksize = []
    dates = []
    now_xmr = 0
    now_btc = 0
    hardfork = datetime.datetime.strptime(
        "2016-03-23", "%Y-%m-%d"
    )  # block time changed here

    for item in data:
        date = datetime.datetime.strftime(item.date, "%Y-%m-%d")
        dates.append(date)
        date = datetime.datetime.strptime(date, "%Y-%m-%d")

        if item.btc_blocksize > 0.001 and item.btc_transactions > 0:
            now_btc += 144 * item.btc_blocksize / 1024
            if now_btc < 200:
                btc_blocksize.append("")
            else:
                btc_blocksize.append(now_btc)
        else:
            btc_blocksize.append("")

        if item.xmr_blocksize > 0.001 and item.xmr_transactions > 0:
            if date < hardfork:
                now_xmr += 1440 * item.xmr_blocksize / 1024
            else:
                now_xmr += 720 * item.xmr_blocksize / 1024

            if now_xmr < 200:
                xmr_blocksize.append("")
            else:
                xmr_blocksize.append(now_xmr)
        else:
            xmr_blocksize.append("")

    now_btc = locale.format("%.2f", now_btc / (1024 * 1024), grouping=True) + " Gb"
    now_xmr = locale.format("%.2f", now_xmr / (1024 * 1024), grouping=True) + " Gb"

    context = {
        "xmr_blocksize": xmr_blocksize,
        "btc_blocksize": btc_blocksize,
        "now_xmr": now_xmr,
        "now_btc": now_btc,
        "dates": dates,
    }
    return render(request, "charts/blockchainsize.html", context)


def securitybudget(request):
    data = DailyData.objects.order_by("date")

    xmr_security = []
    btc_security = []
    dates = []
    now_xmr = 0
    now_btc = 0

    for item in data:
        date = datetime.datetime.strftime(item.date, "%Y-%m-%d")
        dates.append(date)
        if item.btc_minerrevusd > 0.001:
            now_btc = item.btc_minerrevusd / 86400
            btc_security.append(now_btc)
        else:
            btc_security.append("")

        if item.xmr_minerrevusd > 0.001:
            now_xmr = item.xmr_minerrevusd / 86400
            xmr_security.append(now_xmr)
        else:
            xmr_security.append("")

    now_btc = "$" + locale.format("%.2f", now_btc, grouping=True)
    now_xmr = "$" + locale.format("%.2f", now_xmr, grouping=True)

    context = {
        "xmr_security": xmr_security,
        "btc_security": btc_security,
        "now_xmr": now_xmr,
        "now_btc": now_btc,
        "dates": dates,
    }
    return render(request, "charts/securitybudget.html", context)


def efficiency(request):
    data = DailyData.objects.order_by("date")

    xmr_efficiency = []
    btc_efficiency = []
    dates = []
    now_xmr = 0
    now_btc = 0

    for item in data:
        date = datetime.datetime.strftime(item.date, "%Y-%m-%d")
        dates.append(date)
        if item.btc_minerrevusd != 0 and item.btc_inflation > 0:
            if (2**32) * item.btc_difficulty * 0.10 / (
                item.btc_minerrevusd * 24000
            ) > 10:
                now_btc = (
                    (2**32)
                    * item.btc_difficulty
                    * 0.10
                    / (item.btc_minerrevusd * 24000)
                )
            if now_btc > 0.01:
                btc_efficiency.append(now_btc)
            else:
                btc_efficiency.append("")
        else:
            btc_efficiency.append("")

        if item.xmr_minerrevusd != 0 and item.xmr_inflation > 0:
            if item.xmr_difficulty * 0.10 / (item.xmr_minerrevusd * 5000) > 0.01:
                now_xmr = item.xmr_difficulty * 0.10 / (item.xmr_minerrevusd * 5000)
            if now_xmr > 0.01:
                xmr_efficiency.append(now_xmr)
            else:
                xmr_efficiency.append("")
        else:
            xmr_efficiency.append("")

    now_btc = locale.format("%.0f", now_btc, grouping=True)
    now_xmr = locale.format("%.0f", now_xmr, grouping=True)

    context = {
        "xmr_efficiency": xmr_efficiency,
        "btc_efficiency": btc_efficiency,
        "now_xmr": now_xmr,
        "now_btc": now_btc,
        "dates": dates,
    }
    return render(request, "charts/efficiency.html", context)


def compinflation(request):
    data = DailyData.objects.order_by("date")

    dates = []
    inflationxmr = []
    inflationdash = []
    inflationgrin = []
    inflationzcash = []
    inflationbtc = []
    now_xmr = 999999
    now_dash = 999999
    now_grin = 999999
    now_zcash = 999999
    now_btc = 999999

    for item in data:
        dates.append(datetime.datetime.strftime(item.date, "%Y-%m-%d"))

        if item.btc_inflation > 0.1:
            inflationbtc.append(item.btc_inflation)
            now_btc = item.btc_inflation
        else:
            inflationbtc.append("")

        if item.zcash_inflation > 0.1:
            inflationzcash.append(item.zcash_inflation)
            now_zcash = item.zcash_inflation
        else:
            inflationzcash.append("")

        if item.dash_inflation > 0.1:
            inflationdash.append(item.dash_inflation)
            now_dash = item.dash_inflation
        else:
            inflationdash.append("")

        if item.xmr_inflation > 0.1:
            inflationxmr.append(item.xmr_inflation)
            now_xmr = item.xmr_inflation
        else:
            inflationxmr.append("")

        if item.grin_inflation > 0.1:
            inflationgrin.append(item.grin_inflation)
            now_grin = item.grin_inflation
        else:
            inflationgrin.append("")

    now_dash = locale.format("%.2f", now_dash, grouping=True) + "%"
    now_grin = locale.format("%.2f", now_grin, grouping=True) + "%"
    now_zcash = locale.format("%.2f", now_zcash, grouping=True) + "%"
    now_xmr = locale.format("%.2f", now_xmr, grouping=True) + "%"
    now_btc = locale.format("%.2f", now_btc, grouping=True) + "%"

    context = {
        "inflationxmr": inflationxmr,
        "inflationdash": inflationdash,
        "inflationgrin": inflationgrin,
        "inflationzcash": inflationzcash,
        "inflationbtc": inflationbtc,
        "now_xmr": now_xmr,
        "now_btc": now_btc,
        "now_dash": now_dash,
        "now_grin": now_grin,
        "now_zcash": now_zcash,
        "dates": dates,
    }
    return render(request, "charts/compinflation.html", context)


def comptransactions(request):
    data = DailyData.objects.order_by("date")

    dates = []
    xmr = []
    dash = []
    grin = []
    zcash = []
    btc = []
    now_xmr = 999999
    now_dash = 999999
    now_grin = 999999
    now_zcash = 999999
    now_btc = 999999

    for item in data:
        dates.append(datetime.datetime.strftime(item.date, "%Y-%m-%d"))

        if item.btc_transactions > 10:
            btc.append(item.btc_transactions)
            now_btc = item.btc_transactions
        else:
            btc.append("")

        if item.zcash_transactions > 10:
            zcash.append(item.zcash_transactions)
            now_zcash = item.zcash_transactions
        else:
            zcash.append("")

        if item.dash_transactions > 10:
            dash.append(item.dash_transactions)
            now_dash = item.dash_transactions
        else:
            dash.append("")

        if item.xmr_transactions > 10:
            xmr.append(item.xmr_transactions)
            now_xmr = item.xmr_transactions
        else:
            xmr.append("")

        if item.grin_transactions > 10:
            grin.append(item.grin_transactions)
            now_grin = item.grin_transactions
        else:
            grin.append("")

    now_dash = locale.format("%.0f", now_dash, grouping=True)
    now_grin = locale.format("%.0f", now_grin, grouping=True)
    now_zcash = locale.format("%.0f", now_zcash, grouping=True)
    now_xmr = locale.format("%.0f", now_xmr, grouping=True)
    now_btc = locale.format("%.0f", now_btc, grouping=True)

    context = {
        "xmr": xmr,
        "dash": dash,
        "grin": grin,
        "zcash": zcash,
        "btc": btc,
        "now_xmr": now_xmr,
        "now_btc": now_btc,
        "now_dash": now_dash,
        "now_grin": now_grin,
        "now_zcash": now_zcash,
        "dates": dates,
    }
    return render(request, "charts/comptransactions.html", context)


def sfmodel(request):
    dates = []
    stock_to_flow = []
    projection = []
    color = []
    values = []
    now_price = 0
    now_sf = 0
    now_inflation = 0

    data = Sfmodel.objects.order_by("date")
    count_aux = 0
    for item in data:
        if item.color != 0:
            color.append(item.color)
        else:
            color.append("")

        if item.greyline != 0:
            projection.append(item.greyline)
            if count_aux > 25:
                count_aux = 0
            else:
                projection.append(item.greyline)
        else:
            projection.append("")

        if item.stocktoflow > 0.2:
            stock_to_flow.append(item.stocktoflow)
        else:
            stock_to_flow.append("")

        if item.priceusd > 0.1:
            values.append(item.priceusd)
            now_price = item.priceusd
            now_sf = item.stocktoflow
            if item.date > date.today() - timedelta(4):
                coins = Coin.objects.filter(name="xmr").filter(date=item.date)
                if coins:
                    for coin in coins:
                        now_inflation = coin.inflation
        else:
            values.append("")
        count_aux += 1

        dates.append(datetime.datetime.strftime(item.date, "%Y-%m-%d"))

    now_price = "$" + locale.format("%.2f", now_price, grouping=True)
    now_sf = "$" + locale.format("%.2f", now_sf, grouping=True)
    now_inflation = locale.format("%.2f", now_inflation, grouping=True) + "%"

    context = {
        "values": values,
        "dates": dates,
        "stock_to_flow": stock_to_flow,
        "projection": projection,
        "now_price": now_price,
        "now_inflation": now_inflation,
        "now_sf": now_sf,
        "color": color,
    }
    return render(request, "charts/sfmodel.html", context)


def sfmodellin(request):
    dates = []
    stock_to_flow = []
    projection = []
    color = []
    values = []
    now_price = 0
    now_sf = 0
    now_inflation = 0

    data = Sfmodel.objects.order_by("date")
    count_aux = 0
    for item in data:
        if item.color != 0:
            color.append(item.color)
        else:
            color.append("")

        if item.greyline != 0:
            projection.append(item.greyline)
            if count_aux > 25:
                count_aux = 0
            else:
                projection.append(item.greyline)
        else:
            projection.append("")

        if item.stocktoflow > 0.2:
            stock_to_flow.append(item.stocktoflow)
        else:
            stock_to_flow.append("")

        if item.priceusd > 0.1:
            values.append(item.priceusd)
            now_price = item.priceusd
            now_sf = item.stocktoflow
            if item.date > date.today() - timedelta(4):
                coins = Coin.objects.filter(name="xmr").filter(date=item.date)
                if coins:
                    for coin in coins:
                        now_inflation = coin.inflation
        else:
            values.append("")
        count_aux += 1

        dates.append(datetime.datetime.strftime(item.date, "%Y-%m-%d"))

    now_price = "$" + locale.format("%.2f", now_price, grouping=True)
    now_sf = "$" + locale.format("%.2f", now_sf, grouping=True)
    now_inflation = locale.format("%.2f", now_inflation, grouping=True) + "%"

    context = {
        "values": values,
        "dates": dates,
        "stock_to_flow": stock_to_flow,
        "now_price": now_price,
        "now_inflation": now_inflation,
        "now_sf": now_sf,
        "color": color,
    }
    return render(request, "charts/sfmodellin.html", context)


def sfmultiple(request):
    symbol = "xmr"
    now_sf = 0
    maximum = 0
    dates = []
    stock_to_flow = []
    buy = []
    sell = []
    color = []
    v0 = 0.002
    delta = (0.015 - 0.002) / (6 * 365)
    count = 0
    sf_aux = 0
    coins = Coin.objects.order_by("date").filter(name=symbol)
    for coin in coins:
        dates.append(datetime.datetime.strftime(coin.date, "%Y-%m-%d"))
        buy.append(1)
        sell.append(100)
        if coin.stocktoflow > sf_aux * 2 + 250:
            coin.stocktoflow = sf_aux
        sf_aux = coin.stocktoflow
        if coin.priceusd < 1:
            coin.priceusd = 1
        if coin.stocktoflow != 0:
            now_sf = coin.supply * coin.priceusd / (coin.stocktoflow * 1500000)
        stock_to_flow.append(now_sf)
        buy.append(1)
        sell.append(100)
        if now_sf > maximum:
            maximum = now_sf
        new_color = 30 * coin.pricebtc / (count * delta + v0)
        color.append(new_color)
        count += 1

    now_sf = locale.format("%.2f", now_sf, grouping=True)
    maximum = locale.format("%.2f", maximum, grouping=True)

    context = {
        "dates": dates,
        "maximum": maximum,
        "stock_to_flow": stock_to_flow,
        "now_sf": now_sf,
        "buy": buy,
        "sell": sell,
        "color": color,
    }
    return render(request, "charts/sfmultiple.html", context)


def marketcycle(request):
    dates = []
    color = []
    sell = []
    buy = []
    data = Sfmodel.objects.order_by("date")
    for item in data:
        if item.color > 0:
            color.append(item.color - 5)
        else:
            color.append("")

        sell.append(100)
        buy.append(0)
        dates.append(datetime.datetime.strftime(item.date, "%Y-%m-%d"))

    now_cycle = locale.format("%.2f", item.color, grouping=True)

    context = {
        "dates": dates,
        "color": color,
        "sell": sell,
        "buy": buy,
        "now_cycle": now_cycle,
    }
    return render(request, "charts/marketcycle.html", context)


def shielded(request):
    dates = []
    values = []
    values2 = []
    values3 = []

    df = pd.read_excel(DATA_FILE, sheet_name="Sheet1", engine="odf")
    start_row, end_row = 2, 9999
    start_col, end_col = 0, 5
    values_mat = df.iloc[start_row:end_row, start_col:end_col].to_numpy()

    dominance = 0
    monthly = 0

    for k in range(0, len(values_mat)):
        if values_mat[k][0] and values_mat[k][3]:
            date = values_mat[k][0]
            value = values_mat[k][3]
            value3 = values_mat[k][4]
            if not (value) or not (value):
                break
            else:
                dates.append(date)
                values.append(int(value))
                values3.append(int(value3))
        else:
            break

    previous_date = 0
    coins = Coin.objects.order_by("date").filter(name="xmr")
    for date in dates:
        value2 = 0
        for coin in coins:
            aux = str(coin.date)
            month = aux.split("-")[0] + "-" + aux.split("-")[1]
            if month == date:
                if previous_date != coin.date:
                    value2 += coin.transactions
                    previous_date = coin.date

        values2.append(int(value2))

    dominance = 100 * int(value2) / (int(value2) + int(value) + int(value3))
    monthly = int(value2)

    monthly = format(int(monthly), ",")
    dominance = locale.format("%.2f", dominance, grouping=True)

    context = {
        "dates": dates,
        "values": values,
        "values2": values2,
        "values3": values3,
        "monthly": monthly,
        "dominance": dominance,
    }
    return render(request, "charts/shielded.html", context)


def thermocap(request):
    symbol = "xmr"
    dates = []
    values = []
    thermocap = []
    color = []
    v0 = 0.002
    delta = (0.015 - 0.002) / (6 * 365)
    count = 0
    sf_aux = 0
    supply = 0
    calorie = 1
    calories = []
    calories2 = []
    calories3 = []
    coins = Coin.objects.order_by("date").filter(name=symbol)
    for coin in coins:
        dates.append(datetime.datetime.strftime(coin.date, "%Y-%m-%d"))
        if coin.stocktoflow > sf_aux * 2 + 250:
            coin.stocktoflow = sf_aux
        sf_aux = coin.stocktoflow
        values.append(coin.priceusd)
        new_color = 30 * coin.pricebtc / (count * delta + v0)
        color.append(new_color)

        calorie += (coin.supply - supply) * coin.priceusd
        if coin.inflation != 0:
            if calorie / (4200000 * math.sqrt(coin.inflation)) < 0.1:
                calories.append("")
            else:
                calories.append(calorie / (4200000 * math.sqrt(coin.inflation)))
            if calorie / (1000000 * math.sqrt(coin.inflation)) < 0.1:
                calories2.append("")
            else:
                calories2.append(calorie / (1000000 * math.sqrt(coin.inflation)))
            if 28 * calorie / (2500000 * math.sqrt(coin.inflation)) < 0.1:
                calories3.append("")
            else:
                calories3.append(28 * calorie / (2500000 * math.sqrt(coin.inflation)))
        else:
            calories.append("")
        temperature = coin.priceusd / calorie
        if temperature > 0.000004:
            temperature = 0.000004
        thermocap.append(temperature)
        supply = coin.supply
        count += 1

    temperature = locale.format("%.2f", temperature, grouping=True)

    context = {
        "dates": dates,
        "temperature": temperature,
        "values": values,
        "thermocap": thermocap,
        "color": color,
        "calories": calories,
        "calories2": calories2,
        "calories3": calories3,
    }
    return render(request, "charts/thermocap.html", context)


def sharpe(request):
    symbol = "xmr"
    dates = []
    values = []
    color = []
    rocs = []
    sharpe = []
    v0 = 0.002
    delta = (0.015 - 0.002) / (6 * 365)
    count = 0
    price = 0
    coins = Coin.objects.order_by("date").filter(name=symbol)
    for coin in coins:
        new_color = 30 * coin.pricebtc / (count * delta + v0)
        count += 1
        if count % 7 == 0:
            if price == 0:
                if coin.priceusd > 0:
                    price = coin.priceusd
                    roc = 0
                else:
                    roc = 0
            else:
                roc = (coin.priceusd - price) / price
                price = coin.priceusd
            rocs.append(roc)
            dates.append(datetime.datetime.strftime(coin.date, "%Y-%m-%d"))
            values.append(coin.priceusd)
            color.append(new_color)

    n = 52
    median = pd.Series(rocs).rolling(window=n).mean().iloc[n - 1 :].values
    std = pd.Series(rocs).rolling(window=n).std().iloc[n - 1 :].values

    aux = list(map(truediv, median, std))
    for count in range(51):
        sharpe.append("")
    for item in aux:
        sharpe.append(item * math.sqrt(52))

    context = {"dates": dates, "values": values, "color": color, "sharpe": sharpe}
    return render(request, "charts/sharpe.html", context)


def about(request):
    context = {}
    return render(request, "charts/about.html", context)


def transcost(request):
    data = DailyData.objects.order_by("date")
    costbtc = []
    costxmr = []
    dates = []
    now_btc = 0
    now_xmr = 0

    for item in data:
        dates.append(datetime.datetime.strftime(item.date, "%Y-%m-%d"))
        if item.xmr_transcostusd == 0:
            costxmr.append("")
        else:
            costxmr.append(item.xmr_transcostusd)
            now_xmr = item.xmr_transcostusd
        if item.btc_transcostusd == 0:
            costbtc.append("")
        else:
            costbtc.append(item.btc_transcostusd)
            now_btc = item.btc_transcostusd

    now_btc = "$" + locale.format("%.2f", now_btc, grouping=True)
    now_xmr = "$" + locale.format("%.2f", now_xmr, grouping=True)

    context = {
        "costxmr": costxmr,
        "costbtc": costbtc,
        "now_xmr": now_xmr,
        "now_btc": now_btc,
        "dates": dates,
    }
    return render(request, "charts/transcost.html", context)


def transcostntv(request):
    data = DailyData.objects.order_by("date")
    costbtc = []
    costxmr = []
    dates = []
    now_btc = 0
    now_xmr = 0

    for item in data:
        dates.append(datetime.datetime.strftime(item.date, "%Y-%m-%d"))
        if item.xmr_transcostntv == 0:
            costxmr.append("")
        else:
            costxmr.append(item.xmr_transcostntv)
            now_xmr = item.xmr_transcostntv
        if item.btc_transcostntv == 0:
            costbtc.append("")
        else:
            costbtc.append(item.btc_transcostntv)
            now_btc = item.btc_transcostntv

    now_btc = locale.format("%.6f", now_btc, grouping=True)
    now_xmr = locale.format("%.6f", now_xmr, grouping=True)

    context = {
        "costxmr": costxmr,
        "costbtc": costbtc,
        "now_xmr": now_xmr,
        "now_btc": now_btc,
        "dates": dates,
    }
    return render(request, "charts/transcostntv.html", context)


def minerrevcap(request):
    data = DailyData.objects.order_by("date")
    costbtc = []
    costxmr = []
    dates = []
    now_btc = 0
    now_xmr = 0

    for item in data:
        dates.append(datetime.datetime.strftime(item.date, "%Y-%m-%d"))
        if item.xmr_minerrevcap == 0:
            costxmr.append("")
        else:
            costxmr.append(item.xmr_minerrevcap)
            now_xmr = item.xmr_minerrevcap
        if item.btc_minerrevcap == 0:
            costbtc.append("")
        else:
            costbtc.append(item.btc_minerrevcap)
            now_btc = item.btc_minerrevcap

    now_btc = locale.format("%.2f", now_btc, grouping=True) + "%"
    now_xmr = locale.format("%.2f", now_xmr, grouping=True) + "%"

    context = {
        "costxmr": costxmr,
        "costbtc": costbtc,
        "now_xmr": now_xmr,
        "now_btc": now_btc,
        "dates": dates,
    }
    return render(request, "charts/minerrevcap.html", context)


def minerrev(request):
    data = DailyData.objects.order_by("date")
    costbtc = []
    costxmr = []
    dates = []
    now_btc = 0
    now_xmr = 0

    for item in data:
        dates.append(datetime.datetime.strftime(item.date, "%Y-%m-%d"))
        if item.btc_minerrevusd < 0.0001:
            costbtc.append("")
        else:
            costbtc.append(item.btc_minerrevusd)
            now_btc = item.btc_minerrevusd
        if item.xmr_minerrevusd < 0.0001:
            costxmr.append("")
        else:
            costxmr.append(item.xmr_minerrevusd)
            now_xmr = item.xmr_minerrevusd

    now_btc = "$" + locale.format("%.2f", now_btc, grouping=True)
    now_xmr = "$" + locale.format("%.2f", now_xmr, grouping=True)

    context = {
        "costxmr": costxmr,
        "costbtc": costbtc,
        "now_xmr": now_xmr,
        "now_btc": now_btc,
        "dates": dates,
    }
    return render(request, "charts/minerrev.html", context)


def minerrevntv(request):
    data = DailyData.objects.order_by("date")
    costbtc = []
    costxmr = []
    dates = []
    now_btc = 0
    now_xmr = 0
    for item in data:
        dates.append(datetime.datetime.strftime(item.date, "%Y-%m-%d"))
        if item.btc_minerrevntv < 0.0001:
            costbtc.append("")
        else:
            costbtc.append(item.btc_minerrevntv)
            now_btc = item.btc_minerrevntv
        if item.xmr_minerrevntv < 0.0001:
            costxmr.append("")
        else:
            costxmr.append(item.xmr_minerrevntv)
            now_xmr = item.xmr_minerrevntv

    now_btc = locale.format("%.2f", now_btc, grouping=True)
    now_xmr = locale.format("%.2f", now_xmr, grouping=True)

    context = {
        "costxmr": costxmr,
        "costbtc": costbtc,
        "now_xmr": now_xmr,
        "now_btc": now_btc,
        "dates": dates,
    }
    return render(request, "charts/minerrevntv.html", context)


def minerfeesntv(request):
    data = DailyData.objects.order_by("date")
    costbtc = []
    costxmr = []
    dates = []
    now_btc = 0
    now_xmr = 0
    for item in data:
        dates.append(datetime.datetime.strftime(item.date, "%Y-%m-%d"))
        if item.btc_minerfeesntv < 0.1:
            costbtc.append("")
        else:
            costbtc.append(item.btc_minerfeesntv)
            now_btc = item.btc_minerfeesntv
        if item.xmr_minerfeesntv < 0.1:
            costxmr.append("")
        else:
            costxmr.append(item.xmr_minerfeesntv)
            now_xmr = item.xmr_minerfeesntv

    now_btc = locale.format("%.2f", now_btc, grouping=True)
    now_xmr = locale.format("%.2f", now_xmr, grouping=True)

    context = {
        "costxmr": costxmr,
        "costbtc": costbtc,
        "now_xmr": now_xmr,
        "now_btc": now_btc,
        "dates": dates,
    }
    return render(request, "charts/minerfeesntv.html", context)


def minerfees(request):
    data = DailyData.objects.order_by("date")
    costbtc = []
    costxmr = []
    dates = []
    now_btc = 0
    now_xmr = 0
    for item in data:
        dates.append(datetime.datetime.strftime(item.date, "%Y-%m-%d"))
        if item.btc_minerfeesusd < 1:
            costbtc.append("")
        else:
            costbtc.append(item.btc_minerfeesusd)
            now_btc = item.btc_minerfeesusd
        if item.xmr_minerfeesusd < 1:
            costxmr.append("")
        else:
            costxmr.append(item.xmr_minerfeesusd)
            now_xmr = item.xmr_minerfeesusd

    now_btc = locale.format("%.2f", now_btc, grouping=True)
    now_xmr = locale.format("%.2f", now_xmr, grouping=True)

    context = {
        "costxmr": costxmr,
        "costbtc": costbtc,
        "now_xmr": now_xmr,
        "now_btc": now_btc,
        "dates": dates,
    }
    return render(request, "charts/minerfees.html", context)


def dailyemissionntv(request):
    data = DailyData.objects.order_by("date")
    emissionbtc = []
    emissionxmr = []
    dates = []
    now_btc = 0
    now_xmr = 0
    for item in data:
        if item.btc_emissionntv == 0:
            emissionbtc.append("")
        else:
            emissionbtc.append(item.btc_emissionntv)
            now_btc = item.btc_emissionntv

        if item.xmr_emissionntv == 0:
            emissionxmr.append("")
        else:
            emissionxmr.append(item.xmr_emissionntv)
            now_xmr = item.xmr_emissionntv
        dates.append(datetime.datetime.strftime(item.date, "%Y-%m-%d"))

    for i in range(500):
        date_aux = item.date + timedelta(i)
        dates.append(datetime.datetime.strftime(date_aux, "%Y-%m-%d"))
        emissionxmr.append("")
        emissionbtc.append("")

    now_btc = locale.format("%.0f", now_btc, grouping=True)
    now_xmr = locale.format("%.0f", now_xmr, grouping=True)

    context = {
        "emissionxmr": emissionxmr,
        "emissionbtc": emissionbtc,
        "now_xmr": now_xmr,
        "now_btc": now_btc,
        "dates": dates,
    }
    return render(request, "charts/dailyemissionntv.html", context)


def commit(request):
    data = DailyData.objects.order_by("date")
    costbtc = []
    costxmr = []
    dates = []
    now_btc = 0
    now_xmr = 0

    for item in data:
        dates.append(datetime.datetime.strftime(item.date, "%Y-%m-%d"))
        if item.btc_commitusd < 0.000001:
            costbtc.append("")
        else:
            costbtc.append(item.btc_commitusd)
            now_btc = item.btc_commitusd
        if item.xmr_commitusd < 0.000001:
            costxmr.append("")
        else:
            costxmr.append(item.xmr_commitusd)
            now_xmr = item.xmr_commitusd

    now_btc = locale.format("%.2f", now_btc, grouping=True) + " hashs / dollar"
    now_xmr = locale.format("%.2f", now_xmr, grouping=True) + " hashs / dollar"

    context = {
        "costxmr": costxmr,
        "costbtc": costbtc,
        "now_xmr": now_xmr,
        "now_btc": now_btc,
        "dates": dates,
    }
    return render(request, "charts/commit.html", context)


def commitntv(request):
    data = DailyData.objects.order_by("date")
    costbtc = []
    costxmr = []
    dates = []
    now_btc = 0
    now_xmr = 0

    for item in data:
        dates.append(datetime.datetime.strftime(item.date, "%Y-%m-%d"))
        if item.btc_commitntv < 0.00001:
            costbtc.append("")
        else:
            costbtc.append(item.btc_commitntv)
            now_btc = item.btc_commitntv
        if item.xmr_commitntv < 0.00001:
            costxmr.append("")
        else:
            costxmr.append(item.xmr_commitntv)
            now_xmr = item.xmr_commitntv

    now_btc = locale.format("%.0f", now_btc, grouping=True) + " hashs / btc"
    now_xmr = locale.format("%.0f", now_xmr, grouping=True) + " hashs / xmr"

    context = {
        "costxmr": costxmr,
        "costbtc": costbtc,
        "now_xmr": now_xmr,
        "now_btc": now_btc,
        "dates": dates,
    }
    return render(request, "charts/commitntv.html", context)


def competitorssats(request):
    dates = []
    xmr = []
    dash = []
    grin = []
    zcash = []
    count = 0
    now_xmr = 0
    now_dash = 0
    now_grin = 0
    now_zcash = 0
    count = 0
    coins_xmr = Coin.objects.order_by("date").filter(name="xmr")
    for coin_xmr in coins_xmr:
        if coin_xmr.pricebtc:
            if count > 32:
                xmr.append(coin_xmr.pricebtc / 0.0058)
                now_xmr = coin_xmr.pricebtc / 0.0058
            dates.append(count)
            count += 1
        elif count <= 63:
            continue
        else:
            xmr.append("")

    count = 0
    coins_dash = Coin.objects.order_by("date").filter(name="dash")
    for coin_dash in coins_dash:
        count += 1
        if coin_dash.pricebtc and count > 130:
            dash.append(coin_dash.pricebtc / 0.02)
            now_dash = coin_dash.pricebtc / 0.02
        elif count <= 130:
            continue
        else:
            dash.append("")
        dates.append(count)

    count = 0
    coins_grin = Coin.objects.order_by("date").filter(name="grin")
    for coin_grin in coins_grin:
        count += 1
        if coin_grin.pricebtc and count > 155:
            grin.append(coin_grin.pricebtc / 0.000513)
            now_grin = coin_grin.pricebtc / 0.000513
        elif count <= 155:
            continue
        else:
            grin.append("")
        dates.append(count)

    count = 0
    coins_zcash = Coin.objects.order_by("date").filter(name="zec")
    for coin_zcash in coins_zcash:
        count += 1
        if coin_zcash.pricebtc and count > 434:
            zcash.append(coin_zcash.pricebtc / 0.05)
            now_zcash = coin_zcash.pricebtc / 0.05
        elif count <= 434:
            continue
        else:
            zcash.append("")
        dates.append(count)

    now_dash = locale.format("%.3f", now_dash, grouping=True)
    now_grin = locale.format("%.3f", now_grin, grouping=True)
    now_zcash = locale.format("%.3f", now_zcash, grouping=True)
    now_xmr = locale.format("%.3f", now_xmr, grouping=True)

    context = {
        "xmr": xmr,
        "dash": dash,
        "grin": grin,
        "zcash": zcash,
        "now_xmr": now_xmr,
        "now_dash": now_dash,
        "now_grin": now_grin,
        "now_zcash": now_zcash,
        "dates": dates,
    }
    return render(request, "charts/competitorssats.html", context)


def competitorssatslin(request):
    dates = []
    xmr = []
    dash = []
    grin = []
    zcash = []
    count = 0
    now_xmr = 0
    now_dash = 0
    now_grin = 0
    now_zcash = 0
    count = 0
    coins_xmr = Coin.objects.order_by("date").filter(name="xmr")
    for coin_xmr in coins_xmr:
        if coin_xmr.pricebtc:
            if count > 32:
                xmr.append(coin_xmr.pricebtc / 0.0058)
                now_xmr = coin_xmr.pricebtc / 0.0058
            dates.append(count)
            count += 1
        elif count <= 63:
            continue
        else:
            xmr.append("")

    count = 0
    coins_dash = Coin.objects.order_by("date").filter(name="dash")
    for coin_dash in coins_dash:
        count += 1
        if coin_dash.pricebtc and count > 130:
            dash.append(coin_dash.pricebtc / 0.02)
            now_dash = coin_dash.pricebtc / 0.02
        elif count <= 130:
            continue
        else:
            dash.append("")
        dates.append(count)

    count = 0
    coins_grin = Coin.objects.order_by("date").filter(name="grin")
    for coin_grin in coins_grin:
        count += 1
        if coin_grin.pricebtc and count > 155:
            grin.append(coin_grin.pricebtc / 0.000513)
            now_grin = coin_grin.pricebtc / 0.000513
        elif count <= 155:
            continue
        else:
            grin.append("")
        dates.append(count)

    count = 0
    coins_zcash = Coin.objects.order_by("date").filter(name="zec")
    for coin_zcash in coins_zcash:
        count += 1
        if coin_zcash.pricebtc and count > 434:
            zcash.append(coin_zcash.pricebtc / 0.05)
            now_zcash = coin_zcash.pricebtc / 0.05
        elif count <= 434:
            continue
        else:
            zcash.append("")
        dates.append(count)

    now_dash = locale.format("%.3f", now_dash, grouping=True)
    now_grin = locale.format("%.3f", now_grin, grouping=True)
    now_zcash = locale.format("%.3f", now_zcash, grouping=True)
    now_xmr = locale.format("%.3f", now_xmr, grouping=True)

    context = {
        "xmr": xmr,
        "dash": dash,
        "grin": grin,
        "zcash": zcash,
        "now_xmr": now_xmr,
        "now_dash": now_dash,
        "now_grin": now_grin,
        "now_zcash": now_zcash,
        "dates": dates,
    }
    return render(request, "charts/competitorssatslin.html", context)


def dread_subscribers(request):
    dates = []
    data1 = []
    data2 = []
    now_xmr = 0
    now_btc = 0

    df = pd.read_excel(DATA_FILE, sheet_name="Sheet6", engine="odf")
    start_row, end_row = 2, 99
    start_col, end_col = 0, 2
    values_mat = df.iloc[start_row:end_row, start_col:end_col].to_numpy()

    for k in range(0, len(values_mat)):
        if values_mat[k][0] and values_mat[k][2]:
            date = values_mat[k][0]
            value1 = values_mat[k][1]
            value2 = values_mat[k][2]
            if not (value1) or not (value2):
                break
            else:
                dates.append(date)
                data1.append(int(value1))
                data2.append(int(value2))
                now_xmr = int(value2)
                now_btc = int(value1)
        else:
            break

    dominance = 100 * int(value2) / (int(value2) + int(value1))

    now_btc = locale.format("%.0f", now_btc, grouping=True)
    now_xmr = locale.format("%.0f", now_xmr, grouping=True)
    dominance = locale.format("%.2f", dominance, grouping=True)

    context = {
        "dates": dates,
        "now_btc": now_btc,
        "now_xmr": now_xmr,
        "data1": data1,
        "data2": data2,
        "dominance": dominance,
    }
    return render(request, "charts/dread_subscribers.html", context)


def coincards(request):
    dates = []
    data1 = []
    data2 = []
    data3 = []
    data4 = []
    now_xmr = 0
    now_btc = 0

    df = pd.read_excel(DATA_FILE, sheet_name="Sheet2", engine="odf")
    start_row, end_row = 2, 99
    start_col, end_col = 0, 5
    values_mat = df.iloc[start_row:end_row, start_col:end_col].to_numpy()

    for k in range(0, len(values_mat)):
        if values_mat[k][0] and values_mat[k][2]:
            date = values_mat[k][0]
            value1 = values_mat[k][1]
            value2 = values_mat[k][2]
            value3 = values_mat[k][3]
            value4 = values_mat[k][4]
            if not (value1) or not (value2) or not (value3) or not (value4):
                break
            else:
                dates.append(date)
                data1.append(float(value1.replace(",", ".")))
                data2.append(float(value2.replace(",", ".")))
                data3.append(float(value3.replace(",", ".")))
                data4.append(float(value4.replace(",", ".")))
                now_btc = float(value1.replace(",", "."))
                now_xmr = float(value2.replace(",", "."))
                now_eth = float(value3.replace(",", "."))
                now_others = float(value4.replace(",", "."))
        else:
            break

    now_btc = locale.format("%.1f", now_btc, grouping=True)
    now_xmr = locale.format("%.1f", now_xmr, grouping=True)
    now_eth = locale.format("%.1f", now_eth, grouping=True)
    now_others = locale.format("%.1f", now_others, grouping=True)

    context = {
        "dates": dates,
        "now_btc": now_btc,
        "now_xmr": now_xmr,
        "now_eth": now_eth,
        "now_others": now_others,
        "data1": data1,
        "data2": data2,
        "data3": data3,
        "data4": data4,
    }
    return render(request, "charts/coincards.html", context)


def merchants(request):
    dates = []
    data1 = []
    data2 = []
    data3 = []
    data4 = []
    data5 = []
    data6 = []
    data7 = []
    now_xmr = 0
    now_btc = 0
    now_eth = 0

    df = pd.read_excel(DATA_FILE, sheet_name="Sheet3", engine="odf")
    start_row, end_row = 2, 99
    start_col, end_col = 0, 8
    values_mat = df.iloc[start_row:end_row, start_col:end_col].to_numpy()

    for k in range(0, len(values_mat)):
        if values_mat[k][0] and values_mat[k][2]:
            date = values_mat[k][0]
            value1 = values_mat[k][1]
            value2 = values_mat[k][2]
            value3 = values_mat[k][3]
            value4 = values_mat[k][4]
            value5 = values_mat[k][5]
            value6 = values_mat[k][6]
            value7 = values_mat[k][7]
            if (
                not (value1)
                or not (value2)
                or not (value3)
                or not (value4)
                or not (value5)
                or not (value6)
                or not (value7)
            ):
                break
            else:
                dates.append(date)
                data1.append(int(value1))
                data2.append(int(value2))
                data3.append(int(value3))
                data4.append(int(value4))
                data5.append(int(value5))
                data6.append(int(value6))
                data7.append(int(value7))
                now_btc = int(value1)
                now_xmr = int(value2)
                now_eth = int(value3)
        else:
            break

    now_btc = locale.format("%.0f", now_btc, grouping=True)
    now_xmr = locale.format("%.0f", now_xmr, grouping=True)
    now_eth = locale.format("%.0f", now_eth, grouping=True)

    context = {
        "dates": dates,
        "now_btc": now_btc,
        "now_xmr": now_xmr,
        "now_eth": now_eth,
        "data1": data1,
        "data2": data2,
        "data3": data3,
        "data4": data4,
        "data5": data5,
        "data6": data6,
        "data7": data7,
    }
    return render(request, "charts/merchants.html", context)


def merchants_increase(request):
    dates = []
    data1 = []
    data2 = []
    data3 = []
    data4 = []
    data5 = []
    data6 = []
    data7 = []
    now_xmr = 0
    now_btc = 0
    now_eth = 0

    df = pd.read_excel(DATA_FILE, sheet_name="Sheet4", engine="odf")
    start_row, end_row = 2, 99
    start_col, end_col = 0, 8
    values_mat = df.iloc[start_row:end_row, start_col:end_col].to_numpy()

    for k in range(0, len(values_mat)):
        if values_mat[k][0] and values_mat[k][2]:
            date = values_mat[k][0]
            value1 = values_mat[k][1]
            value2 = values_mat[k][2]
            value3 = values_mat[k][3]
            value4 = values_mat[k][4]
            value5 = values_mat[k][5]
            value6 = values_mat[k][6]
            value7 = values_mat[k][7]
            if (
                not (value1)
                or not (value2)
                or not (value3)
                or not (value4)
                or not (value5)
                or not (value6)
                or not (value7)
            ):
                break
            else:
                dates.append(date)
                data1.append(int(value1))
                data2.append(int(value2))
                data3.append(int(value3))
                data4.append(int(value4))
                data5.append(int(value5))
                data6.append(int(value6))
                data7.append(int(value7))
                now_btc = int(value1)
                now_xmr = int(value2)
                now_eth = int(value3)
        else:
            break

    now_btc = locale.format("%.0f", now_btc, grouping=True)
    now_xmr = locale.format("%.0f", now_xmr, grouping=True)
    now_eth = locale.format("%.0f", now_eth, grouping=True)

    context = {
        "dates": dates,
        "now_btc": now_btc,
        "now_xmr": now_xmr,
        "now_eth": now_eth,
        "data1": data1,
        "data2": data2,
        "data3": data3,
        "data4": data4,
        "data5": data5,
        "data6": data6,
        "data7": data7,
    }
    return render(request, "charts/merchants_increase.html", context)


def merchants_percentage(request):
    dates = []
    data1 = []
    data2 = []
    data3 = []
    data4 = []
    data5 = []
    data6 = []
    data7 = []
    now_xmr = 0
    now_btc = 0
    now_eth = 0

    df = pd.read_excel(DATA_FILE, sheet_name="Sheet5", engine="odf")
    start_row, end_row = 2, 99
    start_col, end_col = 0, 8
    values_mat = df.iloc[start_row:end_row, start_col:end_col].to_numpy()

    for k in range(0, len(values_mat)):
        if values_mat[k][0] and values_mat[k][2]:
            date = values_mat[k][0]
            value1 = values_mat[k][1]
            value2 = values_mat[k][2]
            value3 = values_mat[k][3]
            value4 = values_mat[k][4]
            value5 = values_mat[k][5]
            value6 = values_mat[k][6]
            value7 = values_mat[k][7]
            if (
                not (value1)
                or not (value2)
                or not (value3)
                or not (value4)
                or not (value5)
                or not (value6)
                or not (value7)
            ):
                break
            else:
                dates.append(date)
                data1.append(float(value1.replace(",", ".")))
                data2.append(float(value2.replace(",", ".")))
                data3.append(float(value3.replace(",", ".")))
                data4.append(float(value4.replace(",", ".")))
                data5.append(float(value5.replace(",", ".")))
                data6.append(float(value6.replace(",", ".")))
                data7.append(float(value7.replace(",", ".")))
                now_btc = float(value1.replace(",", "."))
                now_xmr = float(value2.replace(",", "."))
                now_eth = float(value3.replace(",", "."))
        else:
            break

    now_btc = locale.format("%.1f", now_btc, grouping=True)
    now_xmr = locale.format("%.1f", now_xmr, grouping=True)
    now_eth = locale.format("%.1f", now_eth, grouping=True)

    context = {
        "dates": dates,
        "now_btc": now_btc,
        "now_xmr": now_xmr,
        "now_eth": now_eth,
        "data1": data1,
        "data2": data2,
        "data3": data3,
        "data4": data4,
        "data5": data5,
        "data6": data6,
        "data7": data7,
    }
    return render(request, "charts/merchants_percentage.html", context)


def dominance(request):
    symbol = "xmr"
    values = []
    pricexmr = []
    dates = []
    now_value = 0
    maximum = 0

    coins = Coin.objects.order_by("date").filter(name=symbol)
    for coin in coins:
        try:
            dominance = Dominance.objects.get(date=coin.date)
            if dominance.dominance > 0:
                values.append(dominance.dominance)
                now_value = dominance.dominance
                if now_value > maximum:
                    maximum = now_value
            else:
                values.append("")
        except Dominance.DoesNotExist:
            values.append("")

        if coin.priceusd > 0.001:
            pricexmr.append(coin.priceusd)
        else:
            pricexmr.append("")

        coin.date = datetime.datetime.strftime(coin.date, "%Y-%m-%d")
        dates.append(coin.date)

    yesterday = date.today() - timedelta(1)
    yesterday = datetime.datetime.strftime(yesterday, "%Y-%m-%d")
    if coin.date == yesterday:
        today = date.today()
        today = datetime.datetime.strftime(today, "%Y-%m-%d")
        try:
            dominance = list(Dominance.objects.order_by("-date"))[0]
            if str(dominance.date) == str(today):
                now_value = dominance.dominance
                dates.append(today)
                values.append(now_value)
                if now_value > maximum:
                    maximum = now_value
        except IndexError:
            pass

    now_value = locale.format("%.2f", now_value, grouping=True)
    maximum = locale.format("%.2f", maximum, grouping=True)

    context = {
        "values": values,
        "dates": dates,
        "maximum": maximum,
        "now_value": now_value,
        "pricexmr": pricexmr,
    }
    return render(request, "charts/dominance.html", context)


def rank(request):
    symbol = "xmr"
    values = []
    pricexmr = []
    dates = []
    now_value = 25
    maximum = 100

    coins = Coin.objects.order_by("date").filter(name=symbol)
    for coin in coins:
        try:
            rank = Rank.objects.get(date=coin.date)
            if rank.rank > 0:
                values.append(rank.rank)
                now_value = rank.rank
                if now_value < maximum:
                    maximum = now_value
            else:
                values.append(now_value)
        except Rank.DoesNotExist:
            values.append(now_value)

        if coin.priceusd > 0.001:
            pricexmr.append(coin.priceusd)
        else:
            pricexmr.append("")

        coin.date = datetime.datetime.strftime(coin.date, "%Y-%m-%d")
        dates.append(coin.date)

    yesterday = date.today() - timedelta(1)
    yesterday = datetime.datetime.strftime(yesterday, "%Y-%m-%d")
    if coin.date == yesterday:
        today = date.today()
        today = datetime.datetime.strftime(today, "%Y-%m-%d")
        try:
            rank = list(Rank.objects.order_by("-date"))[0]
            if str(rank.date) == str(today):
                now_value = rank.rank
                dates.append(today)
                values.append(now_value)
                if now_value < maximum:
                    maximum = now_value
        except IndexError:
            pass

    if now_value == 1:
        now_value = locale.format("%.0f", now_value, grouping=True) + "st"
    if now_value == 2:
        now_value = locale.format("%.0f", now_value, grouping=True) + "nd"
    if now_value == 3:
        now_value = locale.format("%.0f", now_value, grouping=True) + "rd"
    if now_value > 3:
        now_value = locale.format("%.0f", now_value, grouping=True) + "th"
    if maximum == 1:
        maximum = locale.format("%.0f", maximum, grouping=True) + "st"
    if maximum == 2:
        maximum = locale.format("%.0f", maximum, grouping=True) + "nd"
    if maximum == 3:
        maximum = locale.format("%.0f", maximum, grouping=True) + "rd"
    if maximum > 3:
        maximum = locale.format("%.0f", maximum, grouping=True) + "th"

    context = {
        "values": values,
        "dates": dates,
        "maximum": maximum,
        "now_value": now_value,
        "pricexmr": pricexmr,
    }
    return render(request, "charts/rank.html", context)


def p2pool_hashrate(request):
    hashrate = []
    hashrate_mini = []
    combined = []
    dates = []
    now_hashrate = 0
    now_hashrate_mini = 0
    now_combined = 0

    p2pool_stats = P2Pool.objects.order_by("date").filter(mini=False)
    for p2pool_stat in p2pool_stats:
        now_combined = 0
        if p2pool_stat.hashrate and p2pool_stat.percentage > 0:
            now_hashrate = p2pool_stat.hashrate / 1000000
            now_combined = p2pool_stat.hashrate / 1000000
        hashrate.append(now_hashrate)

        try:
            p2pool_stat_mini = P2Pool.objects.filter(mini=True).get(
                date=p2pool_stat.date
            )
            if p2pool_stat_mini.hashrate and p2pool_stat_mini.percentage > 0:
                now_hashrate_mini = p2pool_stat_mini.hashrate / 1000000
                now_combined += p2pool_stat_mini.hashrate / 1000000
        except P2Pool.DoesNotExist:
            pass
        hashrate_mini.append(now_hashrate_mini)
        combined.append(now_combined)

        dates.append(datetime.datetime.strftime(p2pool_stat.date, "%Y-%m-%d"))

    context = {
        "hashrate": hashrate,
        "dates": dates,
        "hashrate_mini": hashrate_mini,
        "combined": combined,
    }
    return render(request, "charts/p2pool_hashrate.html", context)


def p2pool_dominance(request):
    dominance = []
    dominance_mini = []
    dates = []
    combined = []
    now_dominance = 0
    now_dominance_mini = 0

    p2pool_stats = P2Pool.objects.order_by("date").filter(mini=False)
    for p2pool_stat in p2pool_stats:
        now_combined = 0
        if p2pool_stat.hashrate and p2pool_stat.percentage > 0:
            now_dominance = p2pool_stat.percentage
            now_combined += p2pool_stat.percentage
        dominance.append(now_dominance)

        try:
            p2pool_stat_mini = P2Pool.objects.filter(mini=True).get(
                date=p2pool_stat.date
            )
            if p2pool_stat_mini.hashrate and p2pool_stat_mini.percentage > 0:
                now_dominance_mini = p2pool_stat_mini.percentage
                now_combined += p2pool_stat_mini.percentage
        except P2Pool.DoesNotExist:
            pass
        dominance_mini.append(now_dominance_mini)
        combined.append(now_combined)

        dates.append(datetime.datetime.strftime(p2pool_stat.date, "%Y-%m-%d"))

    context = {
        "dominance": dominance,
        "dates": dates,
        "dominance_mini": dominance_mini,
        "combined": combined,
    }
    return render(request, "charts/p2pool_dominance.html", context)


def p2pool_totalblocks(request):
    dates = []
    totalblocks = []
    totalblocks_mini = []
    combined = []
    now_totalblocks = 0
    now_totalblocks_mini = 0
    now_combined = 0

    p2pool_stats = P2Pool.objects.order_by("date").filter(mini=False)
    for p2pool_stat in p2pool_stats:
        now_combined = 0
        if p2pool_stat.totalblocksfound > now_totalblocks:
            now_totalblocks = p2pool_stat.totalblocksfound
            now_combined += p2pool_stat.totalblocksfound
        totalblocks.append(now_totalblocks)

        p2pool_stats_mini = P2Pool.objects.filter(mini=True).filter(
            date=p2pool_stat.date
        )
        for p2pool_stat_mini in p2pool_stats_mini:
            if p2pool_stat_mini.totalblocksfound >= now_totalblocks_mini:
                now_totalblocks_mini = p2pool_stat_mini.totalblocksfound
                now_combined += p2pool_stat_mini.totalblocksfound
                break

        totalblocks_mini.append(now_totalblocks_mini)
        combined.append(now_combined)

        dates.append(datetime.datetime.strftime(p2pool_stat.date, "%Y-%m-%d"))

    context = {
        "totalblocks": totalblocks,
        "totalblocks_mini": totalblocks_mini,
        "dates": dates,
        "combined": combined,
    }
    return render(request, "charts/p2pool_totalblocks.html", context)


def p2pool_totalhashes(request):
    dates = []
    totalblocks = []
    totalblocks_mini = []
    combined = []
    now_totalblocks = 0
    now_totalblocks_mini = 0
    now_combined = 0

    p2pool_stats = P2Pool.objects.order_by("date").filter(mini=False)
    for p2pool_stat in p2pool_stats:
        now_combined = 0
        if p2pool_stat.totalhashes > now_totalblocks:
            now_totalblocks = p2pool_stat.totalhashes / 1000000000000
            now_combined += p2pool_stat.totalhashes / 1000000000000
        totalblocks.append(now_totalblocks)

        try:
            p2pool_stat_mini = P2Pool.objects.filter(mini=True).get(
                date=p2pool_stat.date
            )
            if p2pool_stat_mini.totalhashes >= now_totalblocks_mini:
                now_totalblocks_mini = p2pool_stat_mini.totalhashes / 1000000000000
                now_combined += p2pool_stat_mini.totalhashes / 1000000000000
        except P2Pool.DoesNotExist:
            pass
        totalblocks_mini.append(now_totalblocks_mini)
        combined.append(now_combined)

        dates.append(datetime.datetime.strftime(p2pool_stat.date, "%Y-%m-%d"))

    context = {
        "totalblocks": totalblocks,
        "totalblocks_mini": totalblocks_mini,
        "dates": dates,
        "combined": combined,
    }
    return render(request, "charts/p2pool_totalhashes.html", context)


def p2pool_miners(request):
    miners = []
    miners_mini = []
    dates = []
    combined = []
    now_miners = 0
    now_miners_mini = 0

    p2pool_stats = P2Pool.objects.order_by("date").filter(mini=False)
    for p2pool_stat in p2pool_stats:
        now_combined = 0
        if p2pool_stat.miners > 0:
            now_miners = p2pool_stat.miners
            now_combined += p2pool_stat.miners
        miners.append(now_miners)

        try:
            p2pool_stat_mini = P2Pool.objects.filter(mini=True).get(
                date=p2pool_stat.date
            )
            if p2pool_stat_mini.miners > 0:
                now_miners_mini = p2pool_stat_mini.miners
                now_combined += p2pool_stat_mini.miners
        except P2Pool.DoesNotExist:
            pass
        miners_mini.append(now_miners_mini)
        combined.append(now_combined)

        dates.append(datetime.datetime.strftime(p2pool_stat.date, "%Y-%m-%d"))

    context = {
        "miners": miners,
        "dates": dates,
        "miners_mini": miners_mini,
        "combined": combined,
    }
    return render(request, "charts/p2pool_miners.html", context)


def miningprofitability(request):
    dates = []
    value = []
    now_value = 0

    coins = Coin.objects.order_by("date").filter(name="xmr")
    for coin in coins:
        if coin.hashrate > 0 and coin.priceusd > 0 and coin.revenue > 0:
            if 1000 * coin.priceusd * coin.revenue / coin.hashrate < 5000:
                now_value = 1000 * coin.priceusd * coin.revenue / coin.hashrate
                dates.append(datetime.datetime.strftime(coin.date, "%Y-%m-%d"))
                value.append(now_value)

    context = {"value": value, "dates": dates}
    return render(request, "charts/miningprofitability.html", context)


def tail_emission(request):
    inflationxmr = []
    finflationxmr = []
    dates = []
    now_xmr = 999999

    coins = Coin.objects.order_by("date").filter(name="xmr")
    for coin in coins:
        now_xmr = float(coin.inflation)

    supply = int(coin.supply) * 10**12
    for i in range(210000):
        supply = int(supply)
        reward = (2**64 - 1 - supply) >> 19
        if reward < 0.6 * (10**12):
            reward = 0.6 * (10**12)
        supply += int(720 * reward)
        finflationxmr.append(100 * reward * 720 * 365 / supply)
        date_aux = coin.date + timedelta(i)
        dates.append(datetime.datetime.strftime(date_aux, "%Y-%m-%d"))

    now_xmr = locale.format("%.2f", now_xmr, grouping=True) + "%"

    context = {
        "inflationxmr": inflationxmr,
        "finflationxmr": finflationxmr,
        "now_xmr": now_xmr,
        "dates": dates,
    }
    return render(request, "charts/tail_emission.html", context)


def privacymarketcap(request):
    data = DailyData.objects.order_by("date")

    dates = []
    marketcaps = []
    xmr_marketcaps = []
    now_marketcap = 0
    now_dominance = 0
    top_marketcap = 0
    top_dominance = 0

    for item in data:
        marketcap = 0
        dominance = 0
        dates.append(datetime.datetime.strftime(item.date, "%Y-%m-%d"))
        if item.zcash_marketcap > 1000000:
            marketcap += item.zcash_marketcap

        if item.dash_marketcap > 1000000:
            marketcap += item.dash_marketcap

        if item.grin_marketcap > 1000000:
            marketcap += item.grin_marketcap

        if item.xmr_marketcap > 1000000:
            marketcap += item.xmr_marketcap
            try:
                xmr_dominance = Dominance.objects.get(date=item.date)
                dominance = marketcap * xmr_dominance.dominance / item.xmr_marketcap
            except Dominance.DoesNotExist:
                dominance = now_dominance

            xmr_marketcaps.append(item.xmr_marketcap)
        else:
            xmr_marketcaps.append("")

        now_marketcap = marketcap
        now_dominance = dominance

        if now_marketcap > top_marketcap:
            top_marketcap = now_marketcap
        if now_dominance > top_dominance:
            top_dominance = now_dominance

        if marketcap > 3000000:
            marketcaps.append(marketcap)
        else:
            marketcaps.append("")

    now_marketcap = "$" + locale.format("%.0f", now_marketcap, grouping=True)
    now_dominance = locale.format("%.2f", now_dominance, grouping=True) + "%"
    top_marketcap = "$" + locale.format("%.0f", top_marketcap, grouping=True)
    top_dominance = locale.format("%.2f", top_dominance, grouping=True) + "%"

    context = {
        "marketcaps": marketcaps,
        "now_marketcap": now_marketcap,
        "now_dominance": now_dominance,
        "top_marketcap": top_marketcap,
        "top_dominance": top_dominance,
        "dates": dates,
        "xmr_marketcaps": xmr_marketcaps,
    }
    return render(request, "charts/privacymarketcap.html", context)


def privacydominance(request):
    data = DailyData.objects.order_by("date")
    dates = []
    marketcaps = []
    dominances = []
    now_marketcap = 0
    now_dominance = 0
    top_marketcap = 0
    top_dominance = 0

    for item in data:
        marketcap = 0
        dominance = 0
        dates.append(datetime.datetime.strftime(item.date, "%Y-%m-%d"))
        if item.zcash_marketcap > 100000:
            marketcap += item.zcash_marketcap

        if item.dash_marketcap > 100000:
            marketcap += item.dash_marketcap

        if item.grin_marketcap > 100000:
            marketcap += item.grin_marketcap

        if item.xmr_marketcap > 100000:
            marketcap += item.xmr_marketcap
            try:
                xmr_dominance = Dominance.objects.get(date=item.date)
                dominance = marketcap * xmr_dominance.dominance / item.xmr_marketcap
            except (Dominance.DoesNotExist, ZeroDivisionError):
                dominance = now_dominance

        now_marketcap = marketcap
        now_dominance = dominance

        if now_marketcap > top_marketcap:
            top_marketcap = now_marketcap
        if now_dominance > top_dominance:
            top_dominance = now_dominance

        if marketcap > 300000:
            marketcaps.append(marketcap)
        else:
            marketcaps.append("")

        if dominance > 0:
            dominances.append(dominance)
        else:
            dominances.append("")

    now_marketcap = "$" + locale.format("%.0f", now_marketcap, grouping=True)
    now_dominance = locale.format("%.2f", now_dominance, grouping=True) + "%"
    top_marketcap = "$" + locale.format("%.0f", top_marketcap, grouping=True)
    top_dominance = locale.format("%.2f", top_dominance, grouping=True) + "%"

    context = {
        "marketcaps": marketcaps,
        "dominances": dominances,
        "now_marketcap": now_marketcap,
        "now_dominance": now_dominance,
        "top_marketcap": top_marketcap,
        "top_dominance": top_dominance,
        "dates": dates,
    }
    return render(request, "charts/privacydominance.html", context)


def monerodominance(request):
    data = DailyData.objects.order_by("date")
    dates = []
    marketcaps = []
    xmr_dominance = []
    now_marketcap = 0
    now_dominance = 0
    top_marketcap = 0
    top_dominance = 0
    zec_cap = 0
    dash_cap = 0
    grin_cap = 0

    for item in data:
        marketcap = 0
        dominance = 0
        dates.append(datetime.datetime.strftime(item.date, "%Y-%m-%d"))
        if item.zcash_marketcap > 1000000:
            zec_cap = item.zcash_marketcap
            marketcap += zec_cap
        else:
            marketcap += zec_cap

        if item.dash_marketcap > 1000000:
            dash_cap = item.dash_marketcap
            marketcap += dash_cap
        else:
            marketcap += dash_cap

        if item.grin_marketcap > 1000000:
            grin_cap = item.grin_marketcap
            marketcap += grin_cap
        else:
            marketcap += grin_cap

        if item.xmr_marketcap > 1000000:
            marketcap += item.xmr_marketcap
            dominance = 100 * item.xmr_marketcap / marketcap

        now_marketcap = marketcap
        now_dominance = dominance

        if now_marketcap > top_marketcap:
            top_marketcap = now_marketcap
        if now_dominance > top_dominance:
            top_dominance = now_dominance

        if marketcap > 3000000:
            marketcaps.append(marketcap)
        else:
            marketcaps.append("")

        if dominance > 0:
            xmr_dominance.append(dominance)
        else:
            xmr_dominance.append("")

    now_marketcap = "$" + locale.format("%.0f", now_marketcap, grouping=True)
    now_dominance = locale.format("%.2f", now_dominance, grouping=True) + "%"
    top_marketcap = "$" + locale.format("%.0f", top_marketcap, grouping=True)
    top_dominance = locale.format("%.2f", top_dominance, grouping=True) + "%"

    context = {
        "marketcaps": marketcaps,
        "xmr_dominance": xmr_dominance,
        "now_marketcap": now_marketcap,
        "now_dominance": now_dominance,
        "top_marketcap": top_marketcap,
        "top_dominance": top_dominance,
        "dates": dates,
    }
    return render(request, "charts/monerodominance.html", context)


def withdrawals(request):
    states = []
    dates = []

    withdrawals = Withdrawal.objects.order_by("date")
    for withdrawal in withdrawals:
        dates.append(datetime.datetime.strftime(withdrawal.date, "%Y-%m-%d %H"))
        if withdrawal.state:
            states.append(1)
        else:
            states.append(0)

    context = {"states": states, "dates": dates}
    return render(request, "charts/withdrawals.html", context)