# -*- coding: UTF-8 -*-
import re
import pycurl
import time
import json
import requests
import os
import urllib
import certifi
from pickle import load
from pickle import dump
from vklancer import api
from vklancer import utils
from random import choice,seed,randint
global z, l

def get_biggest_photo(item):
    for items in item:

        if 'photo_2560' in items: return items['photo_2560']
        if 'photo_1280' in items: return items['photo_1280']
        if 'photo_807' in items: return items['photo_807']
        if 'photo_604' in items: return items['photo_604']
        if 'photo_130' in items: return items['photo_130']
        if 'photo_75' in items: return items['photo_75']
        else: return False
def set_vk_token(access_token, AUTH_FILE):
    with open(AUTH_FILE, 'wb') as output:
        dump(access_token, output)


def get_vk_token(AUTH_FILE):
    token = None
    try:
        with open(AUTH_FILE, 'rb') as pkl_file:
            token = load(pkl_file)
    except Exception:
        pass
    return token


def load_config(failname):
    with open(failname) as data_file:
        return json.load(data_file)


def method_errors(data):
    try:
        if data and 'ok' in data:
            return False
        else:
            return True
    except Exception:
        return True


def groupsGetMembers(group_id, offset, count):
    try:
        return vk.groups.getMembers(group_id=group_id, offset=offset,
                                    count=count)
    except Exception:
        print("groupsGetMembers ConnectionResetError; retrying")
        time.sleep(1)
        return groupsGetMembers(group_id=group_id, offset=offset, count=count)


def executeNewFunc(user):
    try:
        return vk.execute.newFunc(user=user)
    except Exception:
        print("executeNewFunc ConnectionResetError; retrying")
        time.sleep(1)
        return executeNewFunc(user=user)


def executeKick(user, gid):
    try:
        return vk.execute.kick(user=user, gid=gid)
    except Exception:
        print("executeKick ConnectionResetError; retrying")
        time.sleep(1)
        return executeKick(user=user, gid=gid)
def getAlbum(albums):
    for item in albums:
        album = vk.photos.get(owner_id=config['owner_id'], album_id=item, offset=0, count=1)
        #print('getting album')
        #print(album)
        if album['response']['count']<500: return item
def albGet(owner_id):
        try:
            return vk.photos.getAlbums(owner_id=user)
        except Exception as ex:
            print("albget error ",ex)
            time.sleep(1)
            return albGet(owner_id)

def rnd_album(random_user):
        seed()

        random_album = choice(users[random_user][1])
        a=0
        for item in ban_list:

            if int(item) == int(random_album):
                a+=1
                break

        if a>0:
            print('banned album')
            return rnd_album(random_user)
        else: return random_album
def errors(owner_id,album_id,offset,count):
    exp = vk.photos.get(owner_id=owner_id, album_id=album_id, offset=offset, count=count)
    time.sleep(0.33)
    if 'error' in exp:
        time.sleep(1)
        return errors(owner_id,album_id,offset,count)
    else:
        return exp
def download_file():
    try:
            with open(ARCHIVE_DIR+'/'+name+'.jpg', 'xb') as f:
                print('dwn start')
                c = pycurl.Curl()
                #c.setopt(pycurl.SSLVERSION, pycurl.SSLVERSION_SSLv3)
                c.setopt(pycurl.CAINFO, certifi.where())
                c.setopt(pycurl.TIMEOUT, 30)
                c.setopt(c.URL, str(get_biggest_photo(photo_id['response']['items'])))
                c.setopt(c.WRITEDATA, f)
                c.perform()
                c.close()
                print('dwn end')
    except Exception as ex:
            print('Error -',ex)
            print('try one more time')
            download_file()
def upload_file(pserver, file,time):
    photo = requests.post(pserver, files=file, timeout=time)
    return photo
def random_photo_get(photos, random_album, random_user):


    if int(photos['response']['count'])>0:
        random_photo=randint(0,(photos['response']['count']-1))
        return random_photo
    else:
        print('LOW ALBUM')
        time.sleep(1)
        random_album=rnd_album(random_user)
        photos=errors(str(user_list[random_user]),str(random_album),0,1)
        return random_photo_get(photos, random_album, random_user)
def main():
        main_album= getAlbum(albums_list)
        #print('album='+main_album)
        a=len(user_list)
        random_user=randint(0,a-1)
        print('user='+str(user_list[random_user]))
        random_album=-15
        photos=vk.photos.get(owner_id=str(user_list[random_user]), album_id=str(random_album), offset=0, count=1)
        if 'error' in photos:
            print('user error')
            return main()
        #print(photos)
        time.sleep(0.5)



        random_photo=random_photo_get(photos, random_album, random_user)


        photo_id=errors(str(user_list[random_user]),str(random_album),random_photo,1) #vk.photos.get(owner_id=users[random_user][0], album_id=random_album, offset=random_photo, count=1)
        print(photo_id)
        main_photo=photo_id['response']['items']
        for unit in main_photo:
                rand_photo=unit
        print(rand_photo['id'])
        print('url='+get_biggest_photo(main_photo))
        name =str(user_list[random_user])+'_'+str(rand_photo['id'])

        if  os.path.exists(ARCHIVE_DIR+'/'+str(name)+'.jpg'):
            print('old file '+str(name))
        else:
            try:
                with open(ARCHIVE_DIR+'/'+name+'.jpg', 'xb') as f:
                    print('dwn start')
                    c = pycurl.Curl()
                    #c.setopt(pycurl.SSLVERSION, pycurl.SSLVERSION_SSLv3)
                    c.setopt(pycurl.CAINFO, certifi.where())
                    c.setopt(pycurl.TIMEOUT, 30)
                    c.setopt(c.URL, str(get_biggest_photo(photo_id['response']['items'])))
                    c.setopt(c.WRITEDATA, f)
                    c.perform()
                    c.close()
                    print('dwn end')
            except Exception as ex:
                print('Error -',ex)
            else:
                print('upl start')
                pserver=vk.photos.getUploadServer(album_id=main_album) #Дальше загрузка картинки из архива
                print(pserver)
                pic = os.listdir(ARCHIVE_DIR)

                file = open(ARCHIVE_DIR+'/'+str(name)+'.jpg','rb')
                try:
                    photo = upload_file(pserver=pserver['response']['upload_url'], file={'file1': file}, time=20)
                except Exception as ex:
                    print('EEEEEEEEEEEXXXXXXXXXXXXXXXXX',ex)
                    time.sleep(10)
                    photo = upload_file(pserver=pserver['response']['upload_url'], file={'file1': file}, time=20)


                text = photo.text
                photo = json.JSONDecoder().decode(text)

                photo = vk.photos.save(album_id=main_album, server=photo['server'], photos_list=photo['photos_list'], hash=photo['hash']) # И сохраняем]
                print(photo)

                file.close()
                print('upl end')
                #time.sleep(1)
                time.sleep(10)

        return main()
a=0
name='1'
m = 0
l = 0
ids = []
like = {'response': 1}
users = []
albums=[]
photos={}
users_count=[]
albums_count=[]
albums_list=[]
ban_list=[]
ARCHIVE_DIR='sohrpics'
user_list = []
text=''
random_user=0
random_album=''
with open('peoples3.txt') as f:
    user_list = f.read().splitlines()
user_list=set(user_list)
user_list=list(user_list)
print('count= ',len(user_list))
#print(user_list)
with open('albums.json') as f:
    albums_list = f.read().splitlines()
config = load_config('config5.json')

access_token = get_vk_token(config['auth_file'])
if not access_token:
    access_token = utils.oauth(login=config['login'],
                               password=config['password'],
                               app_id=config['appid'],
                               scope=config['scope'])


if access_token:
    print("[+] Auth succesfull.")

    vk = api.API(token=access_token, version='5.65')
    set_vk_token(access_token, config['auth_file'])



main()