from dateutil.parser import parse as date_parse
import sqlalchemy
from orm.shout import Shout, ShoutTopic, User
from services.stat.reacted import ReactedStorage
from services.stat.viewed import ViewedByDay
from transliterate import translit
from datetime import datetime
from base.orm import local_session
from migration.extract import prepare_html_body
from orm.community import Community
from orm.reaction import Reaction, ReactionKind

OLD_DATE = "2016-03-05 22:22:00.350000"
ts = datetime.now()
type2layout = {
    "Article": "article",
    "Literature": "prose",
    "Music": "music",
    "Video": "video",
    "Image": "image",
}


def get_shout_slug(entry):
    slug = entry.get("slug", "")
    if not slug:
        for friend in entry.get("friendlySlugs", []):
            slug = friend.get("slug", "")
            if slug:
                break
    return slug


async def migrate(entry, storage):
    # init, set title and layout
    r = {
        "layout": type2layout[entry["type"]],
        "title": entry["title"],
        "community": Community.default_community.id,
        "authors": [],
        "topics": set([]),
        # 'rating': 0,
        # 'ratings': [],
        "createdAt": [],
    }
    topics_by_oid = storage["topics"]["by_oid"]
    users_by_oid = storage["users"]["by_oid"]

    # author

    oid = entry.get("createdBy", entry.get("_id", entry.get("oid")))
    userdata = users_by_oid.get(oid)
    if not userdata:
        app = entry.get("application")
        if app:
            userslug = (
                translit(app["name"], "ru", reversed=True)
                .replace(" ", "-")
                .replace("'", "")
                .replace(".", "-")
                .lower()
            )
            userdata = {
                "username": app["email"],
                "email": app["email"],
                "name": app["name"],
                "bio": app.get("bio", ""),
                "emailConfirmed": False,
                "slug": userslug,
                "createdAt": ts,
                "wasOnlineAt": ts,
            }
        else:
            userdata = User.default_user.dict()
    assert userdata, "no user found for %s from " % [oid, len(users_by_oid.keys())]
    r["authors"] = [
        userdata,
    ]

    # slug

    slug = get_shout_slug(entry)
    if slug:
        r["slug"] = slug
    else:
        raise Exception

    # cover
    c = ""
    if entry.get("thumborId"):
        c = "https://assets.discours.io/unsafe/1600x/" + entry["thumborId"]
    else:
        c = entry.get("image", {}).get("url")
        if not c or "cloudinary" in c:
            c = ""
    r["cover"] = c

    # timestamps

    r["createdAt"] = date_parse(entry.get("createdAt", OLD_DATE))
    r["updatedAt"] = date_parse(entry["updatedAt"]) if "updatedAt" in entry else ts
    if entry.get("published"):
        r["publishedAt"] = date_parse(entry.get("publishedAt", OLD_DATE))
    if "deletedAt" in entry:
        r["deletedAt"] = date_parse(entry["deletedAt"])

    # topics
    category = entry["category"]
    mainTopic = topics_by_oid.get(category)
    if mainTopic:
        r["mainTopic"] = storage["replacements"].get(
            mainTopic["slug"], mainTopic["slug"]
        )
    topic_oids = [
        category,
    ]
    topic_oids.extend(entry.get("tags", []))
    for oid in topic_oids:
        if oid in storage["topics"]["by_oid"]:
            r["topics"].add(storage["topics"]["by_oid"][oid]["slug"])
        else:
            print("[migration] unknown old topic id: " + oid)
    r["topics"] = list(r["topics"])

    entry["topics"] = r["topics"]
    entry["cover"] = r["cover"]
    entry["authors"] = r["authors"]

    # body
    r["body"] = prepare_html_body(entry)

    # save shout to db

    s = object()
    shout_dict = r.copy()
    user = None
    del shout_dict[
        "topics"
    ]  # NOTE: AttributeError: 'str' object has no attribute '_sa_instance_state'
    # del shout_dict['rating'] # NOTE: TypeError: 'rating' is an invalid keyword argument for Shout
    # del shout_dict['ratings']
    email = userdata.get("email")
    slug = userdata.get("slug")
    if not slug:
        raise Exception
    with local_session() as session:
        # c = session.query(Community).all().pop()
        if email:
            user = session.query(User).filter(User.email == email).first()
        if not user and slug:
            user = session.query(User).filter(User.slug == slug).first()
        if not user and userdata:
            try:
                userdata["slug"] = userdata["slug"].lower().strip().replace(" ", "-")
                user = User.create(**userdata)
            except sqlalchemy.exc.IntegrityError:
                print("[migration] user error: " + userdata)
            userdata["id"] = user.id
            userdata["createdAt"] = user.createdAt
            storage["users"]["by_slug"][userdata["slug"]] = userdata
            storage["users"]["by_oid"][entry["_id"]] = userdata
    assert user, "could not get a user"
    shout_dict["authors"] = [
        user,
    ]

    try:
        s = Shout.create(**shout_dict)
    except sqlalchemy.exc.IntegrityError as e:
        with local_session() as session:
            s = session.query(Shout).filter(Shout.slug == shout_dict["slug"]).first()
            bump = False
            if s:
                for key in shout_dict:
                    if key in s.__dict__:
                        if s.__dict__[key] != shout_dict[key]:
                            print(
                                "[migration] shout already exists, but differs in %s"
                                % key
                            )
                            bump = True
                    else:
                        print("[migration] shout already exists, but lacks %s" % key)
                        bump = True
                if bump:
                    s.update(shout_dict)
            else:
                print("[migration] something went wrong with shout: \n%r" % shout_dict)
                raise e
            session.commit()
    except Exception as e:
        print(e)
        print(s)
        raise Exception

    # shout topics aftermath
    shout_dict["topics"] = []
    for tpc in r["topics"]:
        oldslug = tpc
        newslug = storage["replacements"].get(oldslug, oldslug)
        if newslug:
            with local_session() as session:
                shout_topic_old = (
                    session.query(ShoutTopic)
                    .filter(ShoutTopic.shout == shout_dict["slug"])
                    .filter(ShoutTopic.topic == oldslug)
                    .first()
                )
                if shout_topic_old:
                    shout_topic_old.update({"slug": newslug})
                else:
                    shout_topic_new = (
                        session.query(ShoutTopic)
                        .filter(ShoutTopic.shout == shout_dict["slug"])
                        .filter(ShoutTopic.topic == newslug)
                        .first()
                    )
                    if not shout_topic_new:
                        try:
                            ShoutTopic.create(
                                **{"shout": shout_dict["slug"], "topic": newslug}
                            )
                        except:
                            print("[migration] shout topic error: " + newslug)
                session.commit()
            if newslug not in shout_dict["topics"]:
                shout_dict["topics"].append(newslug)
        else:
            print("[migration] ignored topic slug: \n%r" % tpc["slug"])
            # raise Exception

    # content_item ratings to reactions
    try:
        for content_rating in entry.get("ratings", []):
            with local_session() as session:
                rater = (
                    session.query(User)
                    .filter(User.oid == content_rating["createdBy"])
                    .first()
                )
                reactedBy = (
                    rater
                    if rater
                    else session.query(User).filter(User.slug == "noname").first()
                )
                if rater:
                    reaction_dict = {
                        "kind": ReactionKind.LIKE
                        if content_rating["value"] > 0
                        else ReactionKind.DISLIKE,
                        "createdBy": reactedBy.slug,
                        "shout": shout_dict["slug"],
                    }
                    cts = content_rating.get("createdAt")
                    if cts:
                        reaction_dict["createdAt"] = date_parse(cts)
                    reaction = (
                        session.query(Reaction)
                        .filter(Reaction.shout == reaction_dict["shout"])
                        .filter(Reaction.createdBy == reaction_dict["createdBy"])
                        .filter(Reaction.kind == reaction_dict["kind"])
                        .first()
                    )
                    if reaction:
                        reaction_dict["kind"] = (
                            ReactionKind.AGREE
                            if content_rating["value"] > 0
                            else ReactionKind.DISAGREE,
                        )
                        reaction.update(reaction_dict)
                    else:
                        day = (reaction_dict.get("createdAt") or ts).replace(
                            hour=0, minute=0, second=0, microsecond=0
                        )
                        rea = Reaction.create(**reaction_dict)
                        await ReactedStorage.increment(rea)
                    # shout_dict['ratings'].append(reaction_dict)
    except:
        print("[migration] content_item.ratings error: \n%r" % content_rating)
        raise Exception

    # shout views
    ViewedByDay.create(shout=shout_dict["slug"], value=entry.get("views", 1))
    # del shout_dict['ratings']
    shout_dict["oid"] = entry.get("_id")
    storage["shouts"]["by_oid"][entry["_id"]] = shout_dict
    storage["shouts"]["by_slug"][slug] = shout_dict
    return shout_dict