class MyUser(models.Model):
    username = models.CharField('유저네임', unique=True, max_length=30)
    last_name = models.CharField('성', max_length=20)
    first_name = models.CharField('이름', max_length=20)
    nickname = models.CharField('닉네임', max_length=20)
    email = models.EmailField('이메일', blank=True)
    date_joined = models.DateField('가입한 날짜', auto_now_add=True)
    last_modified = models.DateField('수정한 날짜', auto_now=True)

    def __str__(self):
        return self.username

@staticmethod
def create_dummy_user(num):
    """
    num 개수만큼 User1 ~ User<num>까지 임의의 유저를 생성한다.
    :return: 생성된 유저 수
    """
    last_name_list = ['박', '이', '김', '서']
    first_name_list = ['민아', '혜리', '소진', '아영']
    nickname_list = ['빵', '리헬', '쏘지', '율곰']
    created_count = 0
    for i in range(num):
        try:
            MyUser.objects.create(
                username='User {}'.format(i + 1),
                last_name=random.choice(last_name_list),
                first_name=random.choice(first_name_list),
                nickname=random.choice(nickname_list)
            )
            created_count += 1
        except IntegrityError as e:
            print(e)
    return created_count

@staticmethod
def assign_global_variables():
    # sys 모듈은 파이썬 인터프리터 관련 내장모듈
    #  __main__ 모듈을 module 변수에 할당
    module = sys.modules['__main__']
    users = MyUser.objects.filter(username__startswith='User')
    for index, user in enumerate(users):
        # 글로벌 변수를 할당하기 위해서 메인 모듈에서 하는 것
        # __main__ 모듈에 'u1, u2, u3, ...' 이름으로 각 MyUser객체를 할당
        setattr(module, 'u{}'.format(index + 1), user)

def follow(self, user):
    self.following.add(user)

def unfollow(self, myuser):
    self.following.remove(user)

# follower는 수정할 수 없으므로,
# property를 이용해 읽기 전용으로 쓰는게 좋음
@property
def followers(self):
    return self.follower_set.all()

# 위에 3개 메서드는 Many to Many를 다루기 때문에 save가 필요 없지만,
# 이 메서드는 필요함
def change_nickname(self, new_nickname):
    self.nickname = new_nickname
    self.save()

from django.db import models
from member.models import MyUser


class Post(models.Model):
    author = models.ForeignKey(MyUser)
    photo = models.ImageField(upload_to='post', blank=True)
    content = models.TextField(blank=True)
    created_date = models.DateTimeField(auto_now_add=True)
    like_users = models.ManyToManyField(
        MyUser,
        through='PostLike',
        related_name='like_post_set',
    )

    def __str__(self):
        return 'Post[{]]'.format(self.id)

    def toggle_like(self, user):
        # 중간자 모델을 사용하기 때문에 PostLike 중간자 모델 매니저를 사용
        # 핵심은 중간자 모델을 거쳐서 해야한다는 것이다.

        # PostLike 중간자 모델에서 인자로 전달된 Post, MyUser 객체를 가진 row를 조회
        # pl_list = PostLike.objects.filter(post=self, user=user)
        pl_list = self.postlike_set.filter(user=user)

        # 현재 인자로 전달된 user가 해당 Post(self)를 좋아여 한 적이 있는지 검사
        # 만약에 이미 좋아요를 했을 경우 해당 내역을 삭제
        # 아직 내역이 없을 경우 생성
        if pl_list.exists():
            pl_list.delete()
        else:
            PostLike.objects.create(post=self, user=user)

        # 파이썬 삼항연산자
        # [True일 경우 실행할 구문] if 조건문 else [False일 경우 실행할 구문]
        # return PostLike.objects.create(post=self, user=user) if not pl_list.exists() else pl_list.delete()

    def add_comment(self, user, content):
        # 자신에게 연결된 Comment 객체의 역참조 매니저(comment_set)로 부터
        # create 메서드를 이용해 Comment 객체를 생성
        return self.comment_set.create(
            user=user,
            content=content
        )

    @property
    def like_count(self):
        return self.like_users.count()

    @property
    def comment_count(self):
        return self.comment_set.count()


class Comment(models.Model):
    author = models.ForeignKey(MyUser)
    post = models.ForeignKey(Post)
    content = models.TextField()
    created_date = models.DateField(auto_now=True)

    def __str__(self):
        return 'Post[{}]\'s Comment[{}], Author[{}]'.format(
            self.post_id,
            self.id,
            self.author_id,
        )


class PostLike(models.Model):
    user = models.ForeignKey(MyUser)
    post = models.ForeignKey(Post)
    created_date = models.DateTimeField(auto_now=True)

    class Meta:
        unique_together = (
            ('user', 'post'),
        )

    def __str__(self):
        return 'Post[{}]\'s Like[{}]'.format(
            self.post_id,
            self.id,
        )

# instagram/urls.py
from django.conf.urls import url, include
from django.contrib import admin

urlpatterns = [
    url(r'^admin/', admin.site.urls),
    url(r'^member/', include('member.urls')),
]

# member/views.py
from django.http import HttpResponse
from django.shortcuts import render
from django.contrib.auth import authenticate, login


def login(request):
    """
    request.method == 'POST'일 때와 아닐 때의 동작을 구분
    POST일 때는 authenticate, login을 거치는 로직을 실행
    GET일 때는 member/login.html을 render하여 return 한다.
    """
    if request.method == 'POST':
        username = request.POST['username']
        password = request.POST['password']
        # authenticate 인자로 POST로 전달받은 username, password 사용
        user = authenticate(username=username, password=password)
        if user is not None:
            # 장고의 인증관리 시스템을 이용하여 세션을 관리해주기 위해 login() 함수 사용
            login(request, user)
            return HttpResponse('Login Success')
        else:
            return HttpResponse('Login Failed')
    # GET method 요청이 온 경우
    else:
        return render(request, 'member/login.html')

# member/ursl.py
from django.conf.urls import url
from . import views

# 네임스페이스 지정
app_name = 'member'
urlpatterns = [
    url(r'^login/$', views.login, name='login'),
]

# 이렇게 지정해주면 해당 뷰로 이동
handler404 = 'mysite.views.my_custom_page_not_found_view'