from django.http import HttpResponse
import re
import json

general_expression = '\s*(?:url)?\(r?["|\'](?P<pattern>[^\'"]+)["|\'],(?P<main>[^\n]+)\),'

expressions = {
    'view': '\s*(?:url)?\(r?["|\'](?P<pattern>[^\'"]+)["|\'],\s*["|\']?(?P<view>[^\'"]+)["|\']?\),',
    'include': '\s*(?:url)?\(r?["|\'](?P<pattern>[^\'"]+)["|\'],\s*include\(["|\']?(?P<include>[^\'"]+)["|\']?\)\),',
    'direct to template': '\s*(?:url)?\(r?["|\'](?P<pattern>[^\'"]+)["|\'],\s*["|\']?direct_to_template["|\']?,\s*{["|\']template["|\']:\s*["|\'](?P<template>[^\'"]+)["|\']}\),',
}

myurlpatterns = """
from django.conf.urls import patterns, url, include

urlpatterns = patterns('',
    (r'^$', direct_to_template, {'template': 'home.html'}),
    (r'^articles/(\d{4})/$', 'year_archive'),
    (r'^articles/(\d{4})/(\d{2})/$', 'month_archive'),
    (r'^articles/(\d{4})/(\d{2})/(\d+)/$', 'article_detail'),
    (r'^users/', include('users.urls')),
)
"""

myurlpatterns = """from django.conf.urls import patterns, include, url
from django.contrib.staticfiles.urls import staticfiles_urlpatterns
from django.contrib import admin
admin.autodiscover()
from django.conf import settings
import os

urlpatterns = patterns('',
    (r'^$', direct_to_template, {'template': 'home.html'}),
    (r'^urls/', 'urls.views.urls'),
    (r'^admin/', include(admin.site.urls)),
)

if settings.DEBUG:
    urlpatterns += patterns('',
        (r'^css/(?P<path>.*)$', 'django.views.static.serve',
            {'document_root': os.path.join(settings.BASEDIR, 'static/css')}),
        (r'^images/(?P<path>.*)$', 'django.views.static.serve',
            {'document_root': os.path.join(settings.BASEDIR, 'static/images')}),
        (r'^js/(?P<path>.*)$', 'django.views.static.serve',
            {'document_root': os.path.join(settings.BASEDIR, 'static/js')}),
    )"""

def process_line(urlpattern):
    # find which type of urlpattern then parse it
    for expression in expressions:
        m = re.search(expressions[expression], urlpattern)
        if m:
            type = expression
            groupdict = m.groupdict()

            urlpattern_dict = {'type': type}
            urlpattern_dict.update(groupdict)
            return urlpattern_dict
            break
    return

org = "    (r'^users/', include('users.urls')),"
expression = '\s*[url]?\(r?["|\'](?P<pattern>[^\'"]+)["|\'],\s*include\(["|\'](?P<include>[^\'"]+)["|\']\)\),'
newstr = org
newgroupdict = {'pattern': '^new_users/$', 'include': 'users.urls'}
for i, j in newgroupdict.items():
    newstr = newstr.replace(re.search(expression, org).group(i), j)
print newstr

def process_urlpatterns(urlpatterns):
    return [process_line(line) for line in urlpatterns.split('\n') if process_line(line)]

def urls(request):
    if request.POST:
        ids = []
        for key in request.POST:
            m = re.search('(?P<id>[\d]+)[\w_ ]+', key)
            if m:
                ids.append(int(m.group('id')))
        ids = list(set(ids))
        urlpatterns_list = []
        for i in range(len(ids)):
            urlpatterns_list.append({})
        for key, value in request.POST.items():
            m = re.search('(?P<id>[\d]+)_(?P<key>[\w_ ]+)', key)
            if m:
                urlpatterns_list[int(m.group('id'))].update({m.group('key'): value})
        lines = request.POST['code'].split('\n')
        new_lines = []
        i = 0
        s = ''
        extra_import_line = ''
        for line in lines:
            print line
            t = False
            e = None
            for expression in expressions:
                m = re.search(expressions[expression], line)
                if m:
                    t = True
                    e = expressions[expression]
                    print '========================'
                    break
            if t:

                newstr = line
                newgroupdict = urlpatterns_list[i]
                if expression != newgroupdict['type']:
                    print 'new type'
                    new_main = ''
                    if newgroupdict['type'] == 'view':
                        new_main = " '%s'" % (newgroupdict['view'])
                    if newgroupdict['type'] == 'include':
                        new_main = " include('%s')" % (newgroupdict['include'])
                    if newgroupdict['type'] == 'direct to template':
                        if not 'from django.views.generic.simple import direct_to_template' in request.POST['code']:
                            extra_import_line = 'from django.views.generic.simple import direct_to_template\n'

                        new_main = " direct_to_template, {'template': '%s'}" % (newgroupdict['template'])

                    if re.search(general_expression, line):
                        newstr = newstr.replace(re.search(general_expression, line).group('main'), new_main)
                    else:
                        newstr = line
                else:
                    print newstr
                    for key, value in newgroupdict.items():
                    print newgroupdict
                        try:
                            newstr = newstr.replace(re.search(e, line).group(key), value)
                        except:
                            pass

                new_lines.append(newstr)
                i += 1
            else:
                new_lines.append(line)
        response_data = {'code': extra_import_line + '\n'.join(new_lines)}
        return HttpResponse(json.dumps(response_data), mimetype="application/json")

    response_data = {'code': myurlpatterns, 'data': process_urlpatterns(myurlpatterns)}
    return HttpResponse(json.dumps(response_data), mimetype="application/json")

def populate_fields(request):

    response_data = {'data': process_urlpatterns(request.POST['code'])}
    return HttpResponse(json.dumps(response_data), mimetype="application/json")

def modify(request, action):
    code = request.POST['code']

    if action in ['add', 'delete']:

        urlpattern_id = int(request.POST['urlpattern_id'])

        lines = code.split('\n')
        new_lines = []
        i = 0
        s = ''
        for line in lines:
            t = False
            e = None
            for expression in expressions:
                m = re.search(expressions[expression], line)
                if m:
                    t = True
                    e = expressions[expression]
                    break
            if t:
                newstr = line
                print i, urlpattern_id
                if i != urlpattern_id:
                    print newstr
                    new_lines.append(newstr)
                else:
                    if action == 'add':
                        new_lines.append(newstr)
                        new_lines.append("    (r' ', ' '),")
                i += 1
            else:
                new_lines.append(line)
        code = '\n'.join(new_lines)
    response_data = {'code': code, 'data': process_urlpatterns(code)}
    return HttpResponse(json.dumps(response_data), mimetype="application/json")

def reorder(request):
    positions = [int(position[11:]) for i, position in enumerate(request.POST['positions'].split(',')) if i != int(position[11:])]
    print [len(positions) - 1] + range(len(positions) - 1)
    print positions
    if [len(positions) - 1] + range(len(positions) - 1) == positions:
        print 'passed test'
        urlpattern_strings = []
        code = request.POST['code']
        new_lines_positions = []
        lines = code.split('\n')
        new_lines = []
        i = 0
        s = ''
        for line in lines:
            t = False
            e = None
            for expression in expressions:
                m = re.search(expressions[expression], line)
                if m:
                    t = True
                    e = expressions[expression]
                    break
            if t:
                newstr = line
                new_lines.append(newstr)
                #if i in positions:
                new_lines_positions.append(len(new_lines) - 1)
                i += 1
                urlpattern_strings.append(newstr)

            else:
                new_lines.append(line)
        new_lines.insert(new_lines_positions[0], urlpattern_strings[-1])
        del new_lines[new_lines_positions[-1] + 1]
    else:
        positions = sorted([int(position[11:]) for i, position in enumerate(request.POST['positions'].split(',')) if i != int(position[11:])])
        urlpattern_strings = []
        code = request.POST['code']
        new_lines_positions = []
        lines = code.split('\n')
        new_lines = []
        i = 0
        s = ''
        for line in lines:
            t = False
            e = None
            for expression in expressions:
                m = re.search(expressions[expression], line)
                if m:
                    t = True
                    e = expressions[expression]
                    break
            if t:
                newstr = line
                new_lines.append(newstr)
                #if i in positions:
                new_lines_positions.append(len(new_lines) - 1)
                i += 1
                urlpattern_strings.append(newstr)

            else:
                new_lines.append(line)

        print len(new_lines)
        print 'nlp: ', new_lines_positions
        new_lines[new_lines_positions[positions[0]]] = urlpattern_strings[positions[1]]
        print 'positions', positions
        print urlpattern_strings
        print new_lines_positions
        new_lines[new_lines_positions[positions[1]]] = urlpattern_strings[positions[0]]
    response_data = {'code': '\n'.join(new_lines), 'data': process_urlpatterns('\n'.join(new_lines))}
    return HttpResponse(json.dumps(response_data), mimetype="application/json")