def save_source_file(request, project_id, file_id):
    project = get_object_or_404(Project, pk=project_id, owner=request.user)
    source_file = get_object_or_404(SourceFile, pk=file_id, project=project)
    try:
        if source_file.was_modified_since(int(request.POST['modified'])):
            send_td_event('cloudpebble_save_abort_unsafe', data={
                'data': {
                    'filename': source_file.file_name,
                    'kind': 'source'
                }
            }, request=request, project=project)
            raise Exception(_("Could not save: file has been modified since last save."))
        source_file.save_file(request.POST['content'], folded_lines=request.POST['folded_lines'])

    except Exception as e:
        return json_failure(str(e))
    else:
        send_td_event('cloudpebble_save_file', data={
            'data': {
                'filename': source_file.file_name,
                'kind': 'source'
            }
        }, request=request, project=project)

        return json_response({"modified": time.mktime(source_file.last_modified.utctimetuple())})

def view_project(request, project_id):
    project = get_object_or_404(Project, pk=project_id, owner=request.user)
    if project.app_uuid is None:
        project.app_uuid = generate_half_uuid()
    if project.app_company_name is None:
        project.app_company_name = request.user.username
    if project.app_short_name is None:
        project.app_short_name = project.name
    if project.app_long_name is None:
        project.app_long_name = project.app_short_name
    if project.app_version_label is None:
        project.app_version_label = '1.0'
    app_keys = project.get_parsed_appkeys()
    supported_platforms = ["aplite", "basalt"]
    if project.project_type != 'pebblejs' and project.sdk_version != '2':
        supported_platforms.append("chalk")

    send_td_event('cloudpebble_open_project', request=request, project=project)
    try:
        token = request.user.social_auth.get(provider='pebble').extra_data['access_token']
    except:
        token = ''
    return render(request, 'ide/project.html', {
        'project': project,
        'app_keys': app_keys,
        'font_css': settings.TYPOGRAPHY_CSS,
        'libpebble_proxy': json.dumps(settings.LIBPEBBLE_PROXY),
        'token': token,
        'phone_shorturl': settings.PHONE_SHORTURL,
        'supported_platforms': supported_platforms,
        'version_regex': SDK_VERSION_REGEX,
        'npm_manifest_support_enabled': settings.NPM_MANIFEST_SUPPORT
    })

def load_source_file(request, project_id, file_id):
    project = get_object_or_404(Project, pk=project_id, owner=request.user)
    source_file = get_object_or_404(SourceFile, pk=file_id, project=project)
    try:
        content = source_file.get_contents()

        try:
            folded_lines = json.loads(source_file.folded_lines)
        except ValueError:
            folded_lines = []

        send_td_event('cloudpebble_open_file', data={
            'data': {
                'filename': source_file.file_name,
                'kind': 'source'
            }
        }, request=request, project=project)

    except Exception as e:
        return json_failure(str(e))
    else:
        return json_response({
            "success": True,
            "source": content,
            "modified": time.mktime(source_file.last_modified.utctimetuple()),
            "folded_lines": folded_lines
        })

def view_project(request, project_id):
    project = get_object_or_404(Project, pk=project_id, owner=request.user)
    if project.app_uuid is None:
        project.app_uuid = generate_half_uuid()
    if project.app_company_name is None:
        project.app_company_name = request.user.username
    if project.app_short_name is None:
        project.app_short_name = project.name
    if project.app_long_name is None:
        project.app_long_name = project.app_short_name
    if project.app_version_label is None:
        project.app_version_label = '1.0'
    app_keys = project.get_parsed_appkeys()

    send_td_event('cloudpebble_open_project', request=request, project=project)
    try:
        token = request.user.social_auth.get(provider='pebble').extra_data['access_token']
    except:
        token = ''
    return render(request, 'ide/project.html', {
        'project': project,
        'app_keys': app_keys,
        'font_css': settings.TYPOGRAPHY_CSS,
        'libpebble_proxy': json.dumps(settings.LIBPEBBLE_PROXY),
        'token': token,
        'phone_shorturl': settings.PHONE_SHORTURL,
        'supported_platforms': project.supported_platforms,
        'regexes': regexes,
        'regexes_json': json.dumps(regexes.regex_dictionary)
    })

def create_source_file(request, project_id):
    project = get_object_or_404(Project, pk=project_id, owner=request.user)
    try:
        f = SourceFile.objects.create(project=project,
                                      file_name=request.POST['name'],
                                      target=request.POST.get('target', 'app'))
        f.save_text(request.POST.get('content', ''))

    except IntegrityError as e:
        raise BadRequest(str(e))

    send_td_event('cloudpebble_create_file', data={
        'data': {
            'filename': request.POST['name'],
            'kind': 'source',
            'target': f.target
        }
    }, request=request, project=project)

    return {
        'file': {
            'id': f.id,
            'name': f.file_name,
            'target': f.target,
            'file_path': f.project_path
        }
    }

def do_import_github(project_id, github_user, github_project, github_branch, delete_project=False):
    try:
        url = "https://github.com/%s/%s/archive/%s.zip" % (github_user, github_project, github_branch)
        if file_exists(url):
            u = urllib2.urlopen(url)
            return do_import_archive(project_id, u.read())
        else:
            raise Exception("The branch '%s' does not exist." % github_branch)
    except Exception as e:
        try:
            project = Project.objects.get(pk=project_id)
            user = project.owner
        except:
            project = None
            user = None
        if delete_project and project is not None:
            try:
                project.delete()
            except:
                pass
        send_td_event('cloudpebble_github_import_failed', data={
            'data': {
                'reason': e.message,
                'github_user': github_user,
                'github_project': github_project,
                'github_branch': github_branch
            }
        }, user=user)
        raise

def delete_variant(request, project_id, resource_id, variant):
    project = get_object_or_404(Project, pk=project_id, owner=request.user)
    resource = get_object_or_404(ResourceFile, pk=resource_id, project=project)
    if variant == '0':
        variant = ''
    variant_to_delete = resource.variants.get(tags=variant)

    if resource.variants.count() == 1:
        return json_failure("You cannot delete the last remaining variant of a resource.")
    try:
        variant_to_delete.delete()
    except Exception as e:
        return json_failure(str(e))
    else:
        send_td_event('cloudpebble_delete_variant', data={
            'data': {
                'filename': resource.file_name,
                'kind': 'resource',
                'resource-kind': resource.kind,
                'variant': variant
            }
        }, request=request, project=project)

        return json_response({'resource': {
            'variants': [x.get_tags() for x in resource.variants.all()]
        }})

def view_project(request, project_id):
    project = get_object_or_404(Project, pk=project_id, owner=request.user)
    if project.app_uuid is None:
        project.app_uuid = generate_half_uuid()
    if project.app_company_name is None:
        project.app_company_name = request.user.username
    if project.app_short_name is None:
        project.app_short_name = project.name
    if project.app_long_name is None:
        project.app_long_name = project.app_short_name
    if project.app_version_label is None:
        project.app_version_label = '1.0'
    send_td_event('cloudpebble_open_project', request=request, project=project)
    app_keys = sorted(json.loads(project.app_keys).iteritems(), key=lambda x: x[1])
    supported_platforms = ["aplite", "basalt"]
    if project.project_type != 'pebblejs' and project.sdk_version != '2':
        supported_platforms.append("chalk")

    try:
        token = request.user.social_auth.get(provider='pebble').extra_data['access_token']
    except:
        token = ''
    return render(request, 'ide/project.html', {
        'project': project,
        'app_keys': app_keys,
        'font_css': settings.TYPOGRAPHY_CSS,
        'libpebble_proxy': json.dumps(settings.LIBPEBBLE_PROXY),
        'token': token,
        'phone_shorturl': settings.PHONE_SHORTURL,
        'supported_platforms': supported_platforms
    })

def save_project_dependencies(request, project_id):
    project = get_object_or_404(Project, pk=project_id, owner=request.user)
    try:
        project.set_dependencies(json.loads(request.POST['dependencies']))
    except (IntegrityError, ValueError) as e:
        raise BadRequest(str(e))
    else:
        send_td_event('cloudpebble_save_project_settings', request=request, project=project)

def remove_github_auth(request):
    try:
        user_github = request.user.github
        user_github.delete()
    except UserGithub.DoesNotExist:
        pass
    send_td_event("cloudpebble_github_revoked", request=request)
    return HttpResponseRedirect("/ide/settings")

def delete_project(request, project_id):
    project = get_object_or_404(Project, pk=project_id, owner=request.user)
    if not bool(request.POST.get('confirm', False)):
        return json_failure("Not confirmed")
    try:
        project.delete()
    except Exception as e:
        return json_failure(str(e))
    else:
        send_td_event('cloudpebble_delete_project', request=request, project=project)
        return json_response({})

def delete_resource(request, project_id, resource_id):
    project = get_object_or_404(Project, pk=project_id, owner=request.user)
    resource = get_object_or_404(ResourceFile, pk=resource_id, project=project)

    resource.delete()
    send_td_event('cloudpebble_delete_file', data={
        'data': {
            'filename': resource.file_name,
            'kind': 'resource',
            'resource-kind': resource.kind
        }
    }, request=request, project=project)

def delete_source_file(request, project_id, file_id):
    project = get_object_or_404(Project, pk=project_id, owner=request.user)
    source_file = get_object_or_404(SourceFile, pk=file_id, project=project)

    source_file.delete()

    send_td_event('cloudpebble_delete_file', data={
        'data': {
            'filename': source_file.file_name,
            'kind': 'source'
        }
    }, request=request, project=project)

def start_github_auth(request):
    nonce = uuid.uuid4().hex
    try:
        user_github = request.user.github
    except UserGithub.DoesNotExist:
        user_github = UserGithub.objects.create(user=request.user)
    user_github.nonce = nonce
    user_github.save()
    send_td_event("cloudpebble_github_started", request=request)
    return HttpResponseRedirect(
        "https://github.com/login/oauth/authorize?client_id=%s&scope=repo&state=%s" % (settings.GITHUB_CLIENT_ID, nonce)
    )

def npm_search(request):
    try:
        query = request.GET['q']
    except KeyError:
        return {'packages': []}
    search = requests.get('http://node-modules.com/search.json', {'q': query}).json()
    data = {'packages': [filter_dict(package, PACKAGE_SPEC) for package in search]}
    send_td_event('cloudpebble_package_search', data={
        'data': {
            'query': query
        }
    }, request=request)
    return data

def build_log(request, project_id, build_id):
    project = get_object_or_404(Project, pk=project_id, owner=request.user)
    build = get_object_or_404(BuildResult, project=project, pk=build_id)

    log = build.read_build_log()

    send_td_event('cloudpebble_view_build_log', data={
        'data': {
            'build_state': build.state
        }
    }, request=request, project=project)

    return {"log": log}

def get_shortlink(request):
    from utils.td_helper import send_td_event
    url = request.POST['url']
    try:
        r = urllib2.Request('http://api.small.cat/entries', json.dumps({'value': url, 'duration': 60}), headers={'Content-Type': 'application/json'})
        response = json.loads(urllib2.urlopen(r).read())
    except urllib2.URLError as e:
        return json_failure(str(e))
    else:
        send_td_event('cloudpebble_generate_shortlink', data={
            'data': {'short_url': response['url']}
        }, request=request)
        return json_response({'url': response['url']})

def build_log(request, project_id, build_id):
    project = get_object_or_404(Project, pk=project_id, owner=request.user)
    build = get_object_or_404(BuildResult, project=project, pk=build_id)
    try:
        log = build.read_build_log()
    except Exception as e:
        return json_failure(str(e))

    send_td_event('cloudpebble_view_build_log', data={
        'data': {
            'build_state': build.state
        }
    }, request=request, project=project)

    return json_response({"log": log})

def delete_source_file(request, project_id, file_id):
    project = get_object_or_404(Project, pk=project_id, owner=request.user)
    source_file = get_object_or_404(SourceFile, pk=file_id, project=project)
    try:
        source_file.delete()
    except Exception as e:
        return json_failure(str(e))
    else:
        send_td_event('cloudpebble_delete_file', data={
            'data': {
                'filename': source_file.file_name,
                'kind': 'source'
            }
        }, request=request, project=project)
        return json_response({})

def proxy_keen(request, project_id):
    from utils.td_helper import send_td_event
    project = get_object_or_404(Project, pk=project_id)

    acceptable_events = {
        'app_install_succeeded',
        'websocket_connection_failed',
        'app_install_failed',
        'app_log_view',
        'app_log_clear',
        'app_log_download',
        'app_logged_crash',
        'sdk_screenshot_success',
        'sdk_screenshot_failed',
        'cloudpebble_created_ui_layout',
        'cloudpebble_ib_displayed',
        'cloudpebble_ib_created_layer',
        'cloudpebble_android_beta_modal',
        'cloudpebble_android_beta_download',
        'qemu_launched',
        'cloudpebble_timeline_displayed',
        'sdk_pin_inserted',
        'sdk_pin_deleted',
        'cloudpebble_fuzzyprompt_action'
    }

    event = request.POST['event']
    if event not in acceptable_events:
        return json_failure("nope.")

    data = {}
    if 'data' in request.POST:
        data['data'] = json.loads(request.POST['data'])

    if 'device' in request.POST:
        data['device'] = json.loads(request.POST['device'])

    collections = ['cloudpebble', 'sdk']
    if 'collections' in request.POST:
        collections = list(set(collections) & set(json.loads(request.POST['collections'])))

    if len(data.items()) == 0:
        data = None

    send_td_event(event, data=data, request=request, project=project)
    return json_response({})