<?php

namespace Dmcl\AppBundle\Controller;

use Dmcl\AppBundle\Entity\ActivationCode;
use Dmcl\AppBundle\Entity\Device;
use Dmcl\AppBundle\Entity\ExternalContacts;
use Dmcl\AppBundle\Entity\Vod;
use Dmcl\AppBundle\Form\Model\ActivationCodeModel;
use Symfony\Bundle\FrameworkBundle\Controller\Controller,
    Dmcl\AppBundle\Entity\User,
    Symfony\Component\HttpFoundation\Request,
    Symfony\Component\HttpFoundation\Response,
    Symfony\Component\Security\Core\Authentication\Token\UsernamePasswordToken,
    Symfony\Component\Security\Core\SecurityContext,
    Nelmio\ApiDocBundle\Annotation\ApiDoc,
    Symfony\Component\Intl\Intl;
use Symfony\Component\HttpFoundation\JsonResponse;
use Symfony\Component\Security\Core\Authentication\Token\Storage\TokenStorage;

;

class ApiController extends Controller {

    /**
     * @ApiDoc(
     * description="Check the user's credentials",
     * parameters={
     *      {"name"="username", "dataType"="string", "required"=true, "description"="username"},
     *      {"name"="pass", "dataType"="string", "required"=true, "description"="password"}
     *  },
     *     statusCodes={
     *         200="Returned when successful"
     *     }
     * )
     */
    public function loginAction(Request $request) {
        $em = $this->getDoctrine()->getManager();
        $response = array(
            'id' => 0,
            'type' => 0,
            'valid' => 0,
            'outh'=>""
        );
        $user = $request->get('username');
        $pass = $request->get('pass');

        if ($user) {
            $entity = $em->getRepository('AppBundle:User')->findOneByUsername($user);
            if ($entity) {
                $encoder = $this->get('security.encoder_factory')->getEncoder($entity);
                if ($encoder->encodePassword($pass, $entity->getSalt()) == $entity->getPassword()) {
                    $response['id'] = $entity->getId();
                    $response['type'] = 1;
                    $response['valid'] = 1;
                    $response['outh'] = $this->generateUrl("api_auto_login",array("id"=> $entity->getId(),"token"=>base64_encode($entity->getUsername().'-'.$entity->getPassword())),true);
                }
            }
        }


        return new Response(json_encode($response), 200);
    }

    /**
     * @ApiDoc(
     * description="Register a new reseller",
     * parameters={
     *      {"name"="username", "dataType"="string", "required"=true, "description"="username"},
     *      {"name"="email", "dataType"="string", "required"=true, "description"="email"},
     *      {"name"="phone", "dataType"="string", "required"=true, "description"="phone"},
     *      {"name"="pass", "dataType"="string", "required"=true, "description"="password"},
     *      {"name"="name", "dataType"="string", "required"=true, "description"="full name"},
     *      {"name"="country_code", "dataType"="string", "required"=true, "description"="Country Code"}
     *  },
     *     statusCodes={
     *         201="Returned when user is created",
     *         226="Returned when username or email is in use",
     *         400={
     *           "Returned when bad request",
     *         }
     *     }
     * )
     */
    public function registerAction(Request $request) {
        $response = array(
            'code' => 400,
            'id' => 0
        );

        $username = $request->get('username');
        $email = $request->get('email');
        $phone = $request->get('phone');
        $pass = $request->get('pass');
        $name = $request->get('name');
        $country = $request->get('country_code');


        if ($username & $pass & $name) {
            $em = $this->getDoctrine()->getManager();
            $entity = $em->getRepository('AppBundle:User')->findOneByUsername($username);
            if (!$entity) {
                $entity = $em->getRepository('AppBundle:User')->findOneByEmail($email);
                if($entity){
                    $response['code'] = 226;
                }else{
                    $entity = new User();
                    $entity->setName($name);
                    $encoder = $this->get('security.encoder_factory')->getEncoder($entity);
                    $entity->setPassword($encoder->encodePassword($pass, $entity->getSalt()));
                    $entity->setUsername($username);
                    $entity->setUsernameCanonical($username);
                    $entity->setEmail($email);
                    $entity->setEmailCanonical($email);
                    $entity->setEnabled(true);
                    $entity->setCountry(strtoupper($country));
                    $em->persist($entity);
                    $em->flush();
                    $response['code'] = 201;
                    $response['id'] = $entity->getId();
                }
                //201
            } else {
                $response['code'] = 226;
            }
        }

        return new Response(json_encode($response), $response['code']);
    }

    /**
     * @ApiDoc(
     * description="Returns User's profile",
     *   requirements={
     *      {
     *          "name"="id",
     *          "dataType"="integer",
     *          "requirement"="\d+",
     *          "description"="User's Id"
     *      }
     *  },
     *     statusCodes={
     *         200="Returned when successful",
     *         404={
     *           "Returned when the user is not found"
     *         }
     *     }
     * )
     */
    public function profileAction(Request $request, $id) {

        $response = array(
            'status' => 404,
            'name' => '-',
            'username' => '-',
            'country' => '-',
            'email' => '-',
            'phone' => '-',
            'avatar' => '-',
            'address' => '-',
            'customers' => '-',
            'channels_purchase' => array(),
            'vod_purchase' => array(),
            'channels_packages_purchase' => array(),
            'vod_packages_purchase' => array(),
            'custom_channels' => array(),
            'custom_vod' => array(),
            'custom_channels_packages' => array(),
            'custom_vod_packages' => array()
        );

        $em = $this->container->get("doctrine.orm.entity_manager");
        $entity = $em->getRepository('AppBundle:User')->find($id);
        if ($entity) {
            $response['status'] = 200;
            $response['name'] = $entity->getName();
            $response['username'] = $entity->getUsername();
            $response['email'] = $entity->getEmail();
            $response['phone'] = $entity->getPhone();
            $response['avatar'] = $this->generateUrl("_home",array(),true).'uploads/'.$entity->getAvatar();
            $response['address'] = $entity->getAddress();
            $response['customers'] = count($entity->getCustomers());
            \Locale::setDefault($this->container->get("request")->getLocale());
            $response['country'] = Intl::getRegionBundle()->getCountryName($entity->getCountry());

            $channelsSubscriptions = $em->getRepository('AppBundle:Subscriptions')->findBy(array(
                "forTest"=>false,
                "expired"=>false,
                "user"=>$entity,
                "productType"=>"channel",
            ));

            if ($channelsSubscriptions) {
                foreach ($channelsSubscriptions as $channelsSubscription) {
                    $response['channels_purchase'][] = $channelsSubscription->getProductId();
                }
            }

            $channelsPackageSubscriptions = $em->getRepository('AppBundle:Subscriptions')->findBy(array(
                "forTest"=>false,
                "expired"=>false,
                "user"=>$entity,
                "productType"=>"channels_package",
            ));

            if ($channelsPackageSubscriptions) {
                foreach ($channelsPackageSubscriptions as $channelsPackageSubscription) {
                    $response['channels_packages_purchase'][] = $channelsPackageSubscription->getProductId();
                }
            }

            $vodSubscriptions = $em->getRepository('AppBundle:Subscriptions')->findBy(array(
                "forTest"=>false,
                "expired"=>false,
                "user"=>$entity,
                "productType"=>"vod",
            ));

            if ($vodSubscriptions) {
                foreach ($vodSubscriptions as $vodSubscription) {
                    $response['vod_purchase'][] = $vodSubscription->getProductId();
                }
            }

            $vodPackageSubscriptions = $em->getRepository('AppBundle:Subscriptions')->findBy(array(
                "forTest"=>false,
                "expired"=>false,
                "user"=>$entity,
                "productType"=>"vod_package",
            ));

            if ($vodPackageSubscriptions) {
                foreach ($vodPackageSubscriptions as $vodPackageSubscription) {
                    $response['vod_packages_purchase'][] = $vodPackageSubscription->getProductId();
                }
            }

            $customChannels = $em->getRepository('AppBundle:Channel')->findBy(array(
                "owner"=>$entity->getId()
            ));
            if ($customChannels) {
                foreach ($customChannels as $channel) {
                    $response['custom_channels'][] = $channel->getId();
                }
            }

            $customChannelsPackages = $em->getRepository('AppBundle:ChannelsPackage')->findBy(array(
                "owner"=>$entity->getId()
            ));
            if ($customChannelsPackages) {
                foreach ($customChannelsPackages as $channelsPackage) {
                    $response['custom_channels_packages'][] = $channelsPackage->getId();
                }
            }

            $customVods = $em->getRepository('AppBundle:Vod')->findBy(array(
                "owner"=>$entity->getId()
            ));
            if ($customVods) {
                foreach ($customVods as $vod) {
                    $response['custom_vod'][] = $vod->getId();
                }
            }

            $customVodPackages = $em->getRepository('AppBundle:VodPackage')->findBy(array(
                "owner"=>$entity->getId()
            ));
            if ($customVodPackages) {
                foreach ($customVodPackages as $vodPackage) {
                    $response['custom_vod_packages'][] = $vodPackage->getId();
                }
            }

        }
        return new Response(str_replace(array('\/', '//', 'http:/','/../'), array('/', '/', 'http://','/'), json_encode($response)), $response['status']);
    }

    /**
     * @ApiDoc(
     * description="Returns User's channels",
     *   requirements={
     *      {
     *          "name"="userId",
     *          "dataType"="integer",
     *          "requirement"="\d+",
     *          "description"="User's Id"
     *      }
     *  },
     *     statusCodes={
     *         200="Returned when successful",
     *         404={
     *           "Returned when the user is not found"
     *         }
     *     }
     * )
     */
    public function channelsByUserAction(Request $request, $userId) {

        $response = array(
            'status' => 404,
            'channels' => array()
        );

        $em = $this->getDoctrine()->getManager();
        $entity = $em->getRepository('AppBundle:User')->find($userId);
        if ($entity) {
            $response['status'] = 200;
            $channelsSubscriptions = $em->getRepository('AppBundle:Subscriptions')->findBy(array(
                "forTest"=>false,
                "expired"=>false,
                "user"=>$entity,
                "productType"=>"channel",
            ));

            if ($channelsSubscriptions) {
                foreach ($channelsSubscriptions as $channelsSubscription) {
                    $response['channels'][] = $channelsSubscription->getProductId();
                }
            }
        }
        return new Response(str_replace(array('\/', '//', 'http:/'), array('/', '/', 'http://'), json_encode($response)), $response['status']);
    }

    /**
     * @ApiDoc(
     * description="Update User's profile ",
     * parameters={
     *      {"name"="email", "dataType"="string", "required"=true, "description"="email"},
     *      {"name"="phone", "dataType"="string", "required"=true, "description"="phone"},
     *      {"name"="pass", "dataType"="string", "required"=true, "description"="password"},
     *      {"name"="name", "dataType"="string", "required"=true, "description"="full name"},
     *      {"name"="country_code", "dataType"="string", "required"=true, "description"="Country Code"}
     *  },
     *   requirements={
     *      {
     *          "name"="id",
     *          "dataType"="integer",
     *          "requirement"="\d+",
     *          "description"="User's Id"
     *      }
     *  },
     *     statusCodes={
     *         200="Returned when successful",
     *         400=  "Returned when bad request",
     *         226=  "Returned when email already in use",
     *         404={
     *           "Returned when the user is not found",
     *         }
     *     }
     * )
     */
    public function updateProfileAction(Request $request, $id) {
        $response = array(
            'code' => 400,
            'id' => 0
        );

        $email = $request->get('email');
        $phone = $request->get('phone');
        $pass = $request->get('pass');
        $name = $request->get('name');
        $country = $request->get('country_code');

        $em = $this->getDoctrine()->getManager();
        $entity = $em->getRepository('AppBundle:User')->find($id);
        if($email){
            $user = $em->getRepository('AppBundle:User')->findOneByEmail($email);
            if($user){
                if($user->getId()!=$entity->getId()){
                    $response['code'] = 226;
                    return new Response(json_encode($response), $response['code']);
                }
            }

        }
        if ($entity) {
            $entity->setName($name ? $name : $entity->getName());

            if ($pass) {
                $encoder = $this->get('security.encoder_factory')->getEncoder($entity);
                $entity->setPassword($encoder->encodePassword($pass, $entity->getSalt()));
            }
            $entity->setEmail($email ? $email : $entity->getEmail());
            $entity->setPhone($phone ? $phone : $entity->getPhone());
            $entity->setCountry($country ? strtoupper($country) : $entity->getCountry());
            $em->flush();
            $response['code'] = 200;
            $response['id'] = $entity->getId();
            //201
        } else {
            $response['code'] = 404;
        }

        return new Response(json_encode($response), $response['code']);
    }

    /**
     * This method return a collection of all Categories
     * @ApiDoc(
     * description="Returns a collection of Categories",
     * statusCodes={
     *         200="Returned when successful"
     *     }
     * )
     */
    public function categoriesAction(Request $request) {
        $em = $this->getDoctrine()->getManager();
        $response = array();
        $entities = $em->getRepository('AppBundle:ChannelCategories')->findByEnabled(true);

        if ($entities) {
            foreach ($entities as $entity) {
                $response[] = array(
                    'id' => $entity->getId(),
                    'name' => $entity->getName()
                );
            }
        }
        return new Response(json_encode($response), 200);
    }

    /**
     * This method return a collection of all Channels that can be filtered by name and category
     * @ApiDoc(
     * description="Returns a collection of Channels",
     * parameters={
     *      {"name"="name", "dataType"="string", "required"=false, "description"="channel's name"},
     *      {"name"="category", "dataType"="integer", "required"=false, "description"="category id"}
     *  },
     *     statusCodes={
     *         200="Returned when successful"
     *     }
     * )
     */
    public function channelsAction(Request $request) {
        $em = $this->get("doctrine.orm.entity_manager");
        $response = array();
        $category = $request->get('category');
        $name = $request->get('name');
        if ($name & $category) {
            $entities = $em->getRepository('AppBundle:Channel')->findByNameAndCategory($name, $category,"admin");
        } else if ($name) {
            $entities = $em->getRepository('AppBundle:Channel')->findBy(array(
                "name"=>$name,
                "enabled"=>true,
                "owner"=>"admin"
            ));
        } else if ($category) {
            $entities = $em->getRepository('AppBundle:Channel')->findBy(array(
                "category"=>$category,
                "enabled"=>true,
                "owner"=>"admin"
            ));
        } else {
            $entities = $em->getRepository('AppBundle:Channel')->findBy(array(
                "enabled"=>true,
                "owner"=>"admin"
            ));
        }

        if ($entities) {
            foreach ($entities as $entity) {
                $response[] = array(
                    'id' => $entity->getId(),
                    'name' =>$entity->getName(),
                    'live' => $entity->getLive(),
                    'price' => $entity->getPrice(),
                    'logo' => $this->generateUrl('_home', array(), true) .'uploads/' . $entity->getLogo(),
                );
            }
        }
        return new Response(str_replace(array('\/', '//', 'http:/'), array('/', '/', 'http://'), json_encode($response)), 200);
    }

    /**
     * This method return a collection of all Vod Genres
     * @ApiDoc(
     * description="Returns a collection of Vod Genres",
     * statusCodes={
     *         200="Returned when successful"
     *     }
     * )
     */
    public function vodGenresAction(Request $request) {
        $em = $this->get("doctrine.orm.entity_manager");
        $response = array();
        $entities = $em->getRepository('AppBundle:VodGenres')->findByEnabled(true);

        if ($entities) {
            foreach ($entities as $entity) {
                $response[] = array(
                    'id' => $entity->getId(),
                    'name' => $entity->getName()
                );
            }
        }
        return new Response(json_encode($response), 200);
    }

    /**
     * This method return a collection of all Vod
     * @ApiDoc(
     * description="Returns a collection of Vod",
     *     statusCodes={
     *         200="Returned when successful"
     *     }
     * )
     */
    public function videosAction(Request $request) {
        $em = $this->get("doctrine.orm.entity_manager");
        $response = array();
        $entities = $em->getRepository('AppBundle:Vod')->findBy(array(
            "enabled"=>true,
            "owner"=>"admin"
        ));

        if ($entities) {
            foreach ($entities as $entity) {
                $response[] = array(
                    'id' => $entity->getId(),
                    'title' => $entity->getTitle(),
                    'description' => $entity->getDescription(),
                    'genre' => $entity->getGenre()->getName(),
                    'year' => $entity->getYear(),
                    'url' => $entity->getSource(),
                    'cover' => $this->generateUrl('_home', array(), true) .'uploads/' . $entity->getCover(),
                );
            }
        }
        return new Response(str_replace(array('\/', '//', 'http:/'), array('/', '/', 'http://'), json_encode($response)), 200);
    }

    /**
     * This method return a collection of all Free Channels that can be filtered by name and category
     * @ApiDoc(
     * description="Returns a collection of Channels",
     * parameters={
     *      {"name"="name", "dataType"="string", "required"=false, "description"="channel's name"},
     *      {"name"="category", "dataType"="integer", "required"=false, "description"="category id"}
     *  },
     *     statusCodes={
     *         200="Returned when successful"
     *     }
     * )
     */
    public function channelsFreeAction(Request $request) {
        $em = $this->get("doctrine.orm.entity_manager");
        $response = array();
        $category = $request->get('category');
        $name = $request->get('name');
        if ($name & $category) {
            $entities = $em->getRepository('AppBundle:Channel')->findByNameAndCategoryFree($name, $category,"admin");
        } else if ($name) {
            $entities = $em->getRepository('AppBundle:Channel')->findBy(array(
                "name"=>$name,
                "enabled"=>true,
                "price"=>0,
                "owner"=>"admin"
            ));
        } else if ($category) {
            $entities = $em->getRepository('AppBundle:Channel')->findBy(array(
                "category"=>$category,
                "price"=>0,
                "enabled"=>true,
                "owner"=>"admin"
            ));
        } else {
            $entities = $em->getRepository('AppBundle:Channel')->findBy(array(
                "enabled"=>true,
                "price"=>0,
                "owner"=>"admin"
            ));
        }

        if ($entities) {
            foreach ($entities as $entity) {
                $response[] = array(
                    'id' => $entity->getId(),
                    'name' =>$entity->getName(),
                    'live' => $entity->getLive(),
                    'price' => $entity->getPrice(),
                    'logo' => $this->generateUrl('_home', array(), true) .'uploads/' . $entity->getLogo(),
                );
            }
        }
        return new Response(str_replace(array('\/', '//', 'http:/'), array('/', '/', 'http://'), json_encode($response)), 200);
    }

    /**
     * This method return a collection of all Free Vod
     * @ApiDoc(
     * description="Returns a collection of Vod",
     *     statusCodes={
     *         200="Returned when successful"
     *     }
     * )
     */
    public function videosFreeAction(Request $request) {
        $em = $this->get("doctrine.orm.entity_manager");
        $response = array();
        $entities = $em->getRepository('AppBundle:Vod')->findBy(array(
            "enabled"=>true,
            "price"=>0,
            "owner"=>"admin"
        ));

        if ($entities) {
            foreach ($entities as $entity) {
                $response[] = array(
                    'id' => $entity->getId(),
                    'title' => $entity->getTitle(),
                    'description' => $entity->getDescription(),
                    'genre' => $entity->getGenre()->getName(),
                    'year' => $entity->getYear(),
                    'url' => $entity->getSource(),
                    'cover' => $this->generateUrl('_home', array(), true) .'uploads/' . $entity->getCover(),
                );
            }
        }
        return new Response(str_replace(array('\/', '//', 'http:/'), array('/', '/', 'http://'), json_encode($response)), 200);
    }

    /**
     * This method return a collection of all Channels Packages
     * @ApiDoc(
     * description="Returns a collection of Channels Packages",
     *     statusCodes={
     *         200="Returned when successful"
     *     }
     * )
     */
    public function channelsPackagesAction()
    {
        $em = $this->get("doctrine.orm.entity_manager");
        $entities = $em->getRepository('AppBundle:ChannelsPackage')->findBy(array(
            "enabled"=>true,
            "owner"=>"admin"
        ));
        $response = array();
        if ($entities) {
            foreach ($entities as $entity) {
                $packChannels = array();

                foreach ($entity->getChannels() as $channel) {
                    $packChannels[] = array(
                        'id' => $channel->getId(),
                        'name' =>$channel->getName(),
                        'live' => $channel->getLive(),
                        'price' => $channel->getPrice(),
                        'logo' => $this->generateUrl('_home', array(), true) .'uploads/' . $channel->getLogo(),
                        'status'=>$channel->getEnabled(),
                        'category' => $channel->getCategory()->getName()
                    );
                }

                $response[] = array(
                    'id' => $entity->getId(),
                    'name' => $entity->getName(),
                    'price' => $entity->getPrice(),
                    "channels" => $packChannels
                );
            }
        }
        return new Response(str_replace(array('\/', '//', 'http:/'), array('/', '/', 'http://'), json_encode($response)), 200);
    }

    /**
     * This method return a collection of all channels for a package id
     * @ApiDoc(
     * description="Returns a collection of Channels",
     *  requirements={
     *      {
     *          "name"="packageId",
     *          "dataType"="integer",
     *          "requirement"="\d+",
     *          "description"="Package's Id"
     *      }
     *  },
     *     statusCodes={
     *         200="Returned when successful",
     *         404={
     *           "Returned when the package is not found"
     *         }
     *     }
     * )
     */
    public function channelPerPackageAction(Request $request, $packageId) {
        $response = array(
            'status' => 404,
            'channels' => array()
        );

        $em = $this->get("doctrine.orm.entity_manager");
        $entity = $em->getRepository('AppBundle:ChannelsPackage')->findOneBy(array("id" => $packageId, "enabled" => true));
        if ($entity) {
            $response["status"] = 200;
            $packChannels = array();
            foreach ($entity->getChannels() as $channel) {
                $packChannels[] = array(
                    'id' => $channel->getId(),
                    'name' =>$channel->getName(),
                    'live' => $channel->getLive(),
                    'price' => $channel->getPrice(),
                    'logo' => $this->generateUrl('_home', array(), true) .'uploads/' . $channel->getLogo(),
                    'status'=>$channel->getEnabled(),
                    'idcategory' => $channel->getCategory()->getId(),
                    'category' => $channel->getCategory()->getName()
                );
            }
            $response["channels"] = $packChannels;
        }
        return new Response(str_replace(array('\/', '//', 'http:/'), array('/', '/', 'http://'), json_encode($response)), $response["status"]);
    }

    /**
     * This method return a collection of all VOD Packages
     * @ApiDoc(
     * description="Returns a collection of VOD Packages",
     *     statusCodes={
     *         200="Returned when successful"
     *     }
     * )
     */
    public function vodPackagesAction() {
        $em = $this->get("doctrine.orm.entity_manager");
        $entities = $em->getRepository('AppBundle:VodPackage')->findBy(array(
            "enabled"=>true,
            "owner"=>"admin"
        ));
        $response = array();
        if ($entities) {
            foreach ($entities as $entity) {
                $packVods = array();

                foreach ($entity->getVods() as $vod) {
                    $packVods[] = array(
                        'id' => $vod->getId(),
                        'title' => $vod->getTitle(),
                        'description' => $vod->getDescription(),
                        'genre' => $vod->getGenre()->getName(),
                        'year' => $vod->getYear(),
                        'url' => $vod->getSource(),
                        'cover' => $this->generateUrl('_home', array(), true) .'uploads/' . $vod->getCover(),
                    );
                }

                $response[] = array(
                    'id' => $entity->getId(),
                    'name' => $entity->getName(),
                    'price' => $entity->getPrice(),
                    "vod" => $packVods
                );
            }
        }
        return new Response(str_replace(array('\/', '//', 'http:/'), array('/', '/', 'http://'), json_encode($response)), 200);
    }

    /**
     * This method return a collection of all videos for a VOD Packages id
     * @ApiDoc(
     * description="Returns a collection of VOD",
     *  requirements={
     *      {
     *          "name"="packageId",
     *          "dataType"="integer",
     *          "requirement"="\d+",
     *          "description"="Vod-Package's Id"
     *      }
     *  },
     *     statusCodes={
     *         200="Returned when successful",
     *         404={
     *           "Returned when the package is not found"
     *         }
     *     }
     * )
     */
    public function videosPerVodPackageAction(Request $request, $packageId) {
        $response = array(
            'status' => 404,
            'vod' => array()
        );

        $em = $this->get("doctrine.orm.entity_manager");
        $entity = $em->getRepository('AppBundle:VodPackage')->findOneBy(array("id" => $packageId,"enabled"=>true));
        if ($entity) {
            $response["status"] = 200;
            $packVods = array();
            foreach ($entity->getVods() as $vod) {
                $packVods[] = array(
                    'id' => $vod->getId(),
                    'title' => $vod->getTitle(),
                    'description' => $vod->getDescription(),
                    'genre' => $vod->getGenre()->getName(),
                    'year' => $vod->getYear(),
                    'url' => $vod->getSource(),
                    'cover' => $this->generateUrl('_home', array(), true) .'uploads/' . $vod->getCover(),
                );
            }
            $response["vod"] = $packVods;
        }
        return new Response(str_replace(array('\/', '//', 'http:/'), array('/', '/', 'http://'), json_encode($response)), $response["status"]);
    }

    /**
     * This method return a collection of all current programmes for a channel
     * @ApiDoc(
     * description="Returns a collection of Programmes",
     * parameters={
     *      {"name"="date", "dataType"="date", "required"=false, "description"="programme's date"},
     *  },
     *   requirements={
     *      {
     *          "name"="channelId",
     *          "dataType"="integer",
     *          "requirement"="\d+",
     *          "description"="Channel's Id"
     *      }
     *  },
     *     statusCodes={
     *         200="Returned when successful",
     *         404={
     *           "Returned when the Programme is not found",
     *         }
     *     }
     * )
     */
    public function channelProgrammeAction(Request $request, $channelId)
    {
        $response = array(
            'status' => 404,
            'programmes' => array()
        );

        $em = $this->get("doctrine.orm.entity_manager");
        $date = new \DateTime("today");
        if ($request->get("date")) {
            $date = new \DateTime($request->get("date"));
        }

        $entities = $em->getRepository('AppBundle:EpgChannels')->findBy(array("channel" => $channelId));

        if ($entities) {
            $response['status'] = 200;

            foreach ($entities as $entity) {
                foreach ($entity->getProgrammes() as $programme) {
                    if($programme->getDay() == $date){
                        $response['programmes'][] = array(
                            "id" => $programme->getId(),
                            "title" => $programme->getTitle(),
                            "day" => $programme->getDay()->format("Y-m-d"),
                            "start" => $programme->getStartAt()->format("H:t:s"),
                            "xmltvStart" => $programme->getStartAtXMLTV(),
                            "end" => $programme->getEndAt()->format("H:t:s"),
                            "xmltvEnd" => $programme->getEndAtXMLTV()
                        );
                    }
                }
            }
        }
        return new Response(str_replace(array('\/', '//', 'http:/'), array('/', '/', 'http://'), json_encode($response)), $response["status"]);
    }

    /**
     * This method return a collection of all current programmes for a day
     * @ApiDoc(
     * description="Returns a collection of Programmes",
     * parameters={
     *      {"name"="date", "dataType"="date", "required"=false, "description"="programmes's date"},
     *  },
     *     statusCodes={
     *         200="Returned when successful",
     *         404={
     *           "Returned when the Programme is not found",
     *         }
     *     }
     * )
     */
    public function programmesAction(Request $request) {
        $response = array(
            'status' => 404,
            'programmes' => array()
        );

        $em = $this->getDoctrine()->getManager();
        $date = new \DateTime("today");
        if ($request->get("date")) {
            $date = new \DateTime($request->get("date"));
        }
        $entities = $em->getRepository('AppBundle:Programme')->findBy(array("day" => $date), array("startAt" => "ASC"));
        if ($entities) {
            $response['status'] = 200;

            foreach ($entities as $programme) {
                $response['programmes'][] = array(
                    "id" => $programme->getId(),
                    "title" => $programme->getTitle(),
                    "day" => $programme->getDay()->format("Y-m-d"),
                    "start" => $programme->getStartAt()->format("H:t:s"),
                    "xmltvStart" => $programme->getStartAtXMLTV(),
                    "end" => $programme->getEndAt()->format("H:t:s"),
                    "xmltvEnd" => $programme->getEndAtXMLTV()
                );
            }
        }
        return new Response(json_encode($response), $response['status']);
    }

    /**
     * This method return a collection of all customers for one Reseller
     * @ApiDoc(
     * description="Returns a collection of Customers",
     *  requirements={
     *      {
     *          "name"="id",
     *          "dataType"="integer",
     *          "requirement"="\d+",
     *          "description"="Reseller's Id"
     *      }
     *  },
     *     statusCodes={
     *         200="Returned when successful",
     *         404={
     *           "Returned when the Customers are not found",
     *         }
     *     }
     * )
     */
    public function resellerCustomersAction(Request $request,$id) {
        $response = array(
            'status' => 404,
            'customers' => array()
        );

        $em = $this->get("doctrine.orm.entity_manager");
        $reseller = $em->getRepository('AppBundle:User')->find($id);
        if ($reseller) {
            $response['status'] = 200;

            foreach ($reseller->getCustomers() as $customer) {
                \Locale::setDefault($this->container->get("request")->getLocale());
                $response['customers'][] = array(
                    "id" => $customer->getId(),
                    "name" => $customer->getName(),
                    "email" => $customer->getEmail(),
                    "mac" => $customer->getMacs(),
                    "country" =>  Intl::getRegionBundle()->getCountryName($customer->getCountry())
                );
            }
        }
        return new Response(json_encode($response), $response['status']);
    }


    /**
     * This method return a collection of all Playlists for one Reseller
     * @ApiDoc(
     * description="Returns a collection of Playlists",
     *  requirements={
     *      {
     *          "name"="id",
     *          "dataType"="integer",
     *          "requirement"="\d+",
     *          "description"="Reseller's Id"
     *      }
     *  },
     *     statusCodes={
     *         200="Returned when successful",
     *         404={
     *           "Returned when there are no Playlists found",
     *         }
     *     }
     * )
     */
    public function resellerPlaylistsAction(Request $request,$id) {
        $response = array(
            'status' => 404,
            'playlists' => array()
        );


        $em = $this->get("doctrine.orm.entity_manager");
        $playlists = $em->getRepository('AppBundle:Playlists')->findBy(array(
            "owner"=>$id,
            "enabled"=>true
        ));
        if ($playlists) {
            $response['status'] = 200;

            foreach ($playlists as $playlist) {
                $response['playlists'][] = array(
                    "id" => $playlist->getId(),
                    "name" => $playlist->getName(),
                );
            }
        }
        return new Response(json_encode($response), $response['status']);
    }

    /**
     * This method return a collection of all Playlists for one Customer
     * @ApiDoc(
     * description="Returns a collection of Playlists",
     *  requirements={
     *      {
     *          "name"="id",
     *          "dataType"="integer",
     *          "requirement"="\d+",
     *          "description"="Customer's Id"
     *      }
     *  },
     *     statusCodes={
     *         200="Returned when successful",
     *         404={
     *           "Returned when Customer is not found",
     *         }
     *     }
     * )
     */
    public function customerPlaylistsAction(Request $request, $id) {
        $response = array(
            'status' => 404,
            'playlists' => array()
        );

        $em = $this->get("doctrine.orm.entity_manager");
        $customer = $em->getRepository('AppBundle:Customers')->find($id);
        if ($customer) {
            $response['status'] = 200;

            foreach ($customer->getPlaylists() as $playlist) {
                $response['playlists'][] = array(
                    "id" => $playlist->getId(),
                    "name" => $playlist->getName(),
                );
            }
        }
        return new Response(json_encode($response), $response['status']);
    }

    /**
     * This method a Playlist
     * @ApiDoc(
     * description="Returns Playlist",
     *  requirements={
     *      {
     *          "name"="id",
     *          "dataType"="integer",
     *          "requirement"="\d+",
     *          "description"="Playlist's Id"
     *      }
     *  },
     * parameters={
     *      {"name"="owner", "dataType"="string", "required"=false, "description"="playlist's owner"},
     *      {"name"="customer", "dataType"="integer", "required"=false, "description"="customer's id id"}
     *  },
     *     statusCodes={
     *         200="Returned when successful",
     *         404={
     *           "Returned when Playlist is not found",
     *         }
     *     }
     * )
     */
    public function getPlaylistAction(Request $request,$id) {
        $response = array(
            'status' => 404,
            'playlist' => ""
        );

        $em = $this->get("doctrine.orm.entity_manager");
        $playlist = $em->getRepository('AppBundle:Playlists')->find($id);
        if ($playlist) {
            $response['status'] = 200;
            $response['playlist'] = $this->get("app.m3u.services")->generateM3U($playlist,$request->get("owner"),$request->get("customer"));


        }
        return new Response(json_encode($response), $response['status']);
    }

    public function oauthAction(Request $request,$id,$token){
        $em = $this->getDoctrine()->getManager();
        $user = $em->getRepository('AppBundle:User')->find($id);
        if($user){
            if(base64_encode($user->getUsername().'-'.$user->getPassword())==$token){
                $token = new UsernamePasswordToken($user, null, 'main', $user->getRoles());
                $this->container->get('security.token_storage')->setToken($token);
                return $this->redirect($this->generateUrl("fos_user_profile_show"));
            }
        }
        throw $this->createNotFoundException("Token no found");
    }

    /**
     * @ApiDoc(
     * description="This method is used for login an user from a device throw your activation code.",
     * parameters={
     *      {"name"="activationCode", "dataType"="string", "required"=true, "description"="Activation code for login a reseller"},
     *      {"name"="mac", "dataType"="string", "required"=false, "description"="Device's mac"},
     *      {"name"="deviceModel", "dataType"="string", "required"=false, "description"="Device model"},
     *      {"name"="modelNumber", "dataType"="string", "required"=false, "description"="Device's model number"},
     *      {"name"="serialNumber", "dataType"="string", "required"=true, "description"="Device's serial number"}
     *  },
     *     statusCodes={
     *         200="Returned when successful"
     *     }
     * )
     */
    public function activationCodeLoginAction(Request $request)
    {
        try {

            $em = $this->getDoctrine()->getManager();
            $autenticarUsuario = false;
            $activationCode = $em->getRepository('AppBundle:ActivationCode')->findOneBy(array('code' => $request->get('activationCode')));

            if ($activationCode && $request->get('serialNumber')) {
                //Verifico que el codigo no este vecido
                $currentDate = date_create_from_format('d-m-Y', date('d-m-Y'));
                if ($activationCode->getEndDate() && ($activationCode->getEndDate() <= $currentDate)) {
                    $response = array(
                        'error' => true,
                        'msg' => 'The activation code has expired',
                        'data' => null
                    );
                } else {
                    //Si el codigo no esta vencido verifico si es la primera vez que se autentica
                    if ($device = $activationCode->getDevice()) {
                        //Verifico que el device sea el dispositivo que esta intentando autenticarse
                        if ($device->getSerialNumber() == $request->get('serialNumber')) {
                            $autenticarUsuario = true;
                        } else {
                            $response = array(
                                'error' => true,
                                'msg' => 'Code is already activated',
                                'data' => null
                            );
                        }
                    } else {
                        $autenticarUsuario = true;
                    }
                }

                if ($autenticarUsuario) {

                    /**
                     * En caso de que el device no este registrado lo registro, pues es la primera vez que el usuario se autentica.
                     * Ademas se calcula la fecha de inicio y fin de duracion del codigo de activacion
                     */
                    if (!$activationCode->getDevice()) {

                        $activationCode->setEnabled(true);
                        $activationCode->setStartDate(clone $currentDate);
                        $increment = $activationCode->getPeriod();
                        $endDate = date_add($currentDate, date_interval_create_from_date_string("$increment days"));
                        $activationCode->setEndDate($endDate);
                        $em->persist($activationCode);

                        $device = new Device();
                        $device->setMac($request->get('mac'));
                        $device->setDeviceModel($request->get('deviceModel'));
                        $device->setModelNumber($request->get('modelNumber'));
                        $device->setSerialNumber($request->get('serialNumber'));
                        $device->setActivationCode($activationCode);
                        $em->persist($device);

                        $em->flush();
                    }

                    $user = $activationCode->getReseller();
                    $token = new UsernamePasswordToken($user, $user->getPassword(), 'main', $user->getRoles());
                    $this->get('security.token_storage')->setToken($token);

                    $response = array(
                        'error' => false,
                        'msg' => 'User logged successfully',
                        'data' => array(
                            'packageType' => $activationCode->getPackageType(),
                            'channelPackage' => $activationCode->getChannelsPackage() ? $activationCode->getChannelsPackage()->getId() : null,
                            'vodPackage' => $activationCode->getVodPackage() ? $activationCode->getVodPackage()->getId() : null,
                            'start_date' => $activationCode->getStartDate(),
                            'end_date' => $activationCode->getEndDate()
                        )
                    );
                }

            } else {
                $response = array(
                    'error' => true,
                    'msg' => 'Invalid activation code',
                    'data' => null
                );
            }

        } catch(\Exception $ex) {
            $response = array(
                'error' => true,
                'msg' => $ex->getMessage(),
                'data' => null
            );
        }

        return new JsonResponse($response);
    }

    /**
     * @ApiDoc(
     * description="This method is used for listing all countries.",
     *     statusCodes={
     *         200="Returned when successful"
     *     }
     * )
     */
    public function getCountriesAction()
    {
        $countries = $this->getDoctrine()->getRepository('AppBundle:Country')->listCountriesAsArray();
        return new JsonResponse($countries);
    }

    /**
     * @ApiDoc(
     * description="This method is used for requesting a trial activation code.",
     * parameters={
     *      {"name"="email", "dataType"="string", "required"=true, "description"="User's email"},
     *      {"name"="mac", "dataType"="string", "required"=false, "description"="Device's mac"},
     *      {"name"="deviceModel", "dataType"="string", "required"=false, "description"="Device model"},
     *      {"name"="modelNumber", "dataType"="string", "required"=false, "description"="Device's model number"},
     *      {"name"="serialNumber", "dataType"="string", "required"=true, "description"="Device's serial number"}
     *  },
     *     statusCodes={
     *         200="Returned when successful"
     *     }
     * )
     * @param Request $request
     * @return JsonResponse
     */
    public function requestTrialActivationCodeAction(Request $request)
    {
        $em = $this->getDoctrine()->getManager();
        $device = $em->getRepository('AppBundle:Device')->findOneBy(array(
            'serialNumber' => $request->get('serialNumber')
        ));
        if ($device) {
            $response = array(
                'acepted' => false,
                'activationCode' => null
            );
        } else {

            $settings = $em->getRepository('AppBundle:Settings')->findOneBy(array());

            //Creo el codigo de activacion
            $activationCode = new ActivationCode();
            $activationCode->setEnabled(true);
            $activationCode->setPeriod($settings->getTrialPeriodoTime());
            $activationCode->setChannelsPackage($em->getRepository('AppBundle:ChannelsPackage')->findOneBy(array()));
            $activationCode->setPackageType('CHANNELS_PACKAGE');
            $activationCode->setReseller($em->getRepository('AppBundle:User')->find(1));//admin
            $em->persist($activationCode);
            $em->flush();

            //Registro el dispositivo
            $device = new Device();
            $device->setActivationCode($activationCode);
            $device->setDeviceModel($request->get('deviceModel'));
            $device->setMac($request->get('mac'));
            $device->setModelNumber($request->get('modelNumber'));
            $device->setSerialNumber($request->get('serialNumber'));
            $em->persist($device);
            $em->flush();

            //Registro el mensaje externo de trial activation code
            $externalContact = new ExternalContacts();
            $externalContact->setEmail($request->get('email'));
            $externalContact->setNote('Trial activation requested');
            $em->persist($externalContact);
            $em->flush();

            //Le envio el mail al usuario que solicita el codigo
            $this->get('app.services.mailer')->sendMail('Trial Request Activation', $externalContact->getEmail(), $this->renderView('@App/themes/default/EmailTemplate/trialRequestActivation.html.twig', array(
                'activationCode' => $activationCode
            )));

            $response = array(
                'acepted' => true,
                'activationCode' => $activationCode->getCode()
            );
        }

        return new JsonResponse($response);
    }

    /**
     * @ApiDoc(
     * description="This method is used for saving a request of e trial activation code.",
     * parameters={
     *      {"name"="email", "dataType"="string", "required"=true, "description"="User's email"},
     *      {"name"="name", "dataType"="string", "required"=false, "description"="User's name"},
     *      {"name"="country", "dataType"="string", "required"=false, "description"="User's country"},
     *      {"name"="city", "dataType"="string", "required"=false, "description"="User's city"},
     *  },
     *     statusCodes={
     *         200="Returned when successful"
     *     }
     * )
     * @param Request $request
     * @return JsonResponse
     */
    public function requestInfoAction(Request $request)
    {
        try {
            $em = $this->getDoctrine()->getManager();

            $externalContact = new ExternalContacts();
            $externalContact->setEmail($request->get('email'));
            $externalContact->setName($request->get('name'));
            $externalContact->setCountry($em->getRepository('AppBundle:Country')->find($request->get('country')));
            $externalContact->setCity($request->get('city'));
            $externalContact->setNote('Resquesting information');

            $em->persist($externalContact);
            $em->flush();

            $response = array();

        } catch(\Exception $ex) {
            $response = array(
                'error' => $ex->getMessage()
            );
        }

        return new JsonResponse($response);
    }

    /**
     * @ApiDoc(
     * description="This method is used for listing all video packages.",
     *     statusCodes={
     *         200="Returned when successful"
     *     }
     * )
     * @return JsonResponse
     */
    public function getVodPackagePlaylistAction()
    {
        $vodPackages = $this->getDoctrine()->getRepository('AppBundle:VodPackage')->findAll();

        $response = array();
        foreach ($vodPackages as $vodPackage) {

            $vods = array();
            foreach ($vodPackage->getVods() as $vod) {
                array_push($vods, array(
                    'video_id' => $vod->getId(),
                    'video_name' => $vod->getTitle(),
                    'category' => $vod->getGenre()->getName(),
                    'category_id' => $vod->getGenre()->getId(),
                    'duration' => $vod->getDuration(),
                    'description' => $vod->getDescription()
                ));
            }

            array_push($response, array(
                'vod_package_id' => $vodPackage->getId(),
                'logo' => $this->get('vich_uploader.templating.helper.uploader_helper')->asset($vodPackage, 'packageLogoFile'),
                'category_id' => $vodPackage->getVodGenre()->getId(),
                'category' => $vodPackage->getVodGenre()->getName(),
                'start' => $vodPackage->getStartTime(),
                'playlist_url' => $vodPackage->getLive(),
                'price' => $vodPackage->getPrice(),
                'server_timezone' => date_default_timezone_get(),
                'vods' => $vods
            ));
        }

        return new JsonResponse($response);
    }

}