import telegram
from telegram.error import NetworkError
import requests
from requests import ConnectionError
from urllib3.exceptions import ResponseError
from dotenv import load_dotenv
from os import getenv
import os


V = 5.92


class VkAPIUnavailable(Exception):
    pass


class FaceBookAPIUnavailable(Exception):
    pass


class OSException(Exception):
    pass


def open_img_to_upload(path_to_img):
    try:
        image_file_descriptor = open(path_to_img, 'rb')
    except (OSError, PermissionError, FileNotFoundError):
        raise OSException("Failed to open image file - {} !\n"
                          "Possible reasons:\n"
                          "-Permission error\n"
                          "-File doesn't exist\n"
                          "-File descriptor is open".format(path_to_img))
    img_obj_for_vk = {'photo': image_file_descriptor}
    return img_obj_for_vk


def upload_photo_to_vk(url, files):
    try:
        response = requests.post(url, files=files)
        if not response.ok:
            raise ResponseError
    except (ConnectionError, ResponseError):
        raise VkAPIUnavailable("{} is not available!".format(url))
    content = response.json()
    try:
        photo = content['photo']
        server = content['server']
        hash = content['hash']
        if not all([photo, server, hash]):
            raise KeyError
        return photo, server, hash
    except KeyError:
        raise VkAPIUnavailable("Something went wrong"
                               " during uploading photo to vk!\n"
                               "API-method - {}".format(url))


def save_img_to_vk(access_token, photo, group_id, server, img_hash):
    payload = {
        "access_token": access_token,
        "group_id": group_id,
        "photo": photo,
        "server": server,
        "hash": img_hash,
        "v": V
    }
    url = "https://api.vk.com/method/photos.saveWallPhoto"
    try:
        response = requests.post(url, params=payload)
        if not response.ok:
            raise ResponseError
    except (ConnectionError, ResponseError):
        raise VkAPIUnavailable("{} is not available!".format(url))
    try:
        content = response.json()['response'][0]
        media_id = content['id']
        owner_id = content['owner_id']
        return media_id, owner_id
    except KeyError:
        print(type(response.text))
        error_code = response.text['error']['error_code']
        error_msg = response.text['error']['error_msg']
        raise VkAPIUnavailable("Something went wrong"
                               " during saving photo to vk!\n"
                               "API-method - {}\n"
                               "error_code - {}\n"
                               "error_msg - {}".format(url,
                                                       error_code,
                                                       error_msg
                                                       ))


def get_vk_upload_adress(vk_group_id, access_token):
    payload = {
        "access_token": access_token,
        "scope": "photos",
        "group_id": vk_group_id,
        "v": V
    }
    url = "https://api.vk.com/method/photos.getWallUploadServer"
    try:
        response = requests.get(url, params=payload)
        if not response.ok:
            raise ResponseError
    except (ConnectionError, ResponseError):
        raise VkAPIUnavailable("{} is not available!".format(url))
    content = response.json()
    try:
        upload_url = content['response']['upload_url']
    except KeyError:
        error_code = content['error']['error_code']
        error_msg = content['error']['error_msg']
        raise VkAPIUnavailable("Something went wrong"
                               " during getting vk-upload_url !\n"
                               "API-method - {}\n"
                               "error_code - {}\n"
                               "error_msg - {}".format(url,
                                                       error_code,
                                                       error_msg
                                                       ))
    return upload_url


def post_photo_to_vk_wall(
        group_id,
        owner_id,
        media_id,
        message,
        access_token
):
    payload = {
        "owner_id": "-{}".format(group_id),
        "message": message,
        "attachments": "photo{}_{}".format(owner_id, media_id),
        "from_group": 1,
        "v": V,
        "access_token": access_token

    }
    url = "https://api.vk.com/method/wall.post"
    try:
        response = requests.post(url, params=payload)
        if not response.ok:
            raise ResponseError
    except (ConnectionError, ResponseError):
        raise VkAPIUnavailable("{} is not available!".format(url))
    content = response.json()
    try:
        post_id = content["response"]["post_id"]
    except KeyError:
        error_code = content['error']['error_code']
        error_msg = content['error']['error_msg']
        raise VkAPIUnavailable("Something went wrong"
                               " during posting to vk-wall!\n"
                               "API-method - {}\n"
                               "error_code - {}\n"
                               "error_msg - {}".format(url,
                                                       error_code,
                                                       error_msg
                                                       ))
    return post_id


def post_to_telegram(photo, text, chat_id, token):
    os.environ['HTTPS_PROXY'] = "https://76.87.197.15:80"
    os.environ['HTTP_PROXY'] = "https://76.87.197.15:80"# http://spys.one/proxys/US/
    bot = telegram.Bot(token=token)
    bot.send_message(chat_id=chat_id, text=text)
    bot.send_photo(chat_id=chat_id, photo=photo)
    return True


def post_to_facebook(
        access_token,
        group_id,
        photo,
        message
):
    dest_url = "{}/{}/photos".format("https://graph.facebook.com", group_id)
    payload = {
        'access_token': access_token,
        'message': message,
        'published': True,
     }
    files = {'source': photo}
    # files = {'source': open('test_img.jpg', 'rb')}
    try:
        response = requests.post(dest_url, params=payload, files=files)
        if not response.ok:
            raise FaceBookAPIUnavailable(response.text)
        return True
    except (ConnectionError, ResponseError):
        raise FaceBookAPIUnavailable("{} is not available!".format(dest_url))


if __name__ == '__main__':
    load_dotenv()
    vk_access_token = getenv("vk_access_token")
    vk_group_id = getenv("vk_group_id")
    bot_token = getenv("telegram_bot_token")
    chat_id = getenv("telegram_channel_name")
    facebook_access_token = getenv("facebook_token")
    facebook_group_id = getenv("facebook_group")
    message = 'aaaaaaa!!!!!'
    try:
        img_obj_for_vk = open_img_to_upload('test_img.jpg')
    except OSException as error:
        exit(error)
    try:
        upload_url = get_vk_upload_adress(
            vk_group_id,
            vk_access_token
        )
        uploaded_photo, server, img_hash = upload_photo_to_vk(
            upload_url,
            img_obj_for_vk
        )
        media_id, owner_id = save_img_to_vk(
            vk_access_token,
            uploaded_photo,
            vk_group_id,
            server,
            img_hash
        )
        post_to_vk = post_photo_to_vk_wall(
            vk_group_id,
            owner_id,
            media_id,
            message,
            vk_access_token
        )
    except (VkAPIUnavailable) as error:
        print(error)
    try:
        post_to_facebook = post_to_facebook(
            facebook_access_token,
            facebook_group_id,
            img_obj_for_vk['photo'],
            message
        )
    except FaceBookAPIUnavailable as error:
        print(error)
    try:
        telegram_posted = post_to_telegram(
            img_obj_for_vk['photo'],
            message,
            chat_id,
            bot_token
        )
    except NetworkError as error:
        print(error)
    img_obj_for_vk['photo'].close()