/*

 * Copyright 2012 Tomas Zeman <tzeman@volny.cz>

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *     http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */

package fis.crm.ui

import fis.aaa.model.User

import fis.aaa.ui.IfLoggedIn

import fis.base.model._

import fis.base.ui._

import fis.crm.model._

import fis.geo.model._

import fis.pm.model.CompanyProjects

import fis.pm.ui.ProjectTable

import net.liftweb.common._

import net.liftweb.http._

import net.liftweb.http.js.JsCmds.RedirectTo

import net.liftweb.sitemap._

import net.liftweb.sitemap.Loc._

import net.liftweb.util._

import net.liftweb.util.Helpers._

import net.tz.lift.model._

import net.tz.lift.snippet._

import scala.xml.{Elem, NodeSeq, Text}

object CompanySnippet extends CompanyCrud with EntitySnippet[Company] {

  val prefix = "company"

  private val listPre = Menu("company.list", l10n("Companies")) / prefix >>

    Title(_ => i18n("Companies")) >>

    locTpl("entity/list") >> Snippet("list", list)

  private val createPre = Menu("company.create", l10n("Create")) / prefix / ADD >>

    Title(_ => i18n("Create company")) >> IfLoggedIn.test >>

    locTpl("company/form") >> Snippet("form", form) >> Hidden

  private val viewPre = Menu.param[Company]("company.view", l10n("Company"), parse,

    encode) / prefix / * >> Title(c => i18n("Company %s", c.linkName)) >>

    locTpl("company/view") >> Snippet("panel", panel) >>

    Snippet("projects", projects) >> Hidden

  private val editPre = Menu.param[Company]("company.edit", l10n("Edit"), parse,

    encode) / prefix / * / EDIT >>

    Title(c => i18n("Edit company %s", c.linkName)) >> IfLoggedIn.testVal >>

    locTpl("company/form") >> Snippet("form", form) >> Hidden

  private val deletePre = Menu.param[Company]("company.delete", l10n("Delete"),

    parse, encode) / prefix / * / DELETE >>

    Title(c => i18n("Delete company %s", c.linkName)) >> IfLoggedIn.testVal >>

    locTpl("entity/delete") >> Snippet("form", deleteF) >> Hidden

  private val listM = listPre >> SecNav(createPre).build

  private val createM = createPre >> SecNav(listPre).build

  private val viewM = viewPre >>

  private val editM = editPre >> SecNav(viewPre).build

  private val deleteM = deletePre >> SecNav(viewPre).build

  private lazy val viewLoc = viewM.toLoc

  private lazy val editLoc = editM.toLoc

  private lazy val deleteLoc = deleteM.toLoc

    contacts.chooseM, contacts.confirmM)

  private def cur = viewLoc.currentValue or editLoc.currentValue or

    deleteLoc.currentValue

  private def list: CssTr = { _ => CompanyTable(Company.companies()) }

  private def panel: CssTr = "*" #> cur.map(CompanyPanel(_))

  private def projects: CssTr = "*" #> cur.map { c =>

    ProjectTable(CompanyProjects(c)) }

  object url {

    def view: Company => Box[String] = (viewLoc.calcHref _) andThen (Box !! _)

  }

  private case class CompanyLink(c: Company) extends EntityLink[Company](c,

    url.view)

  EntityLink.register[Company](CompanyLink(_))

  private object form extends HorizontalScreen with CancelButton with SaveButton {

    private object company extends ScreenVar[Company](Company.createRecord)

    private object address extends ScreenVar[Address](Address.createRecord)

    private object postAddress extends ScreenVar[Address](Address.createRecord)

    private val hasPostAddr = builder(Company.postAddress.displayName, false,

      FormFieldId("has_post_address")).

      help(i18n("Post address differs from company address")).make

    override def screenFields: List[BaseField] =

      fields(company) flatMap(_.allFields)

    private def fields(c: Company): List[FieldContainer] = {

      List[FieldContainer](c.name, c.ico, c.dic, c.status,

        ReadOnlyField.labelOnly(c.address)) ++

      address.formFields ++

      List[FieldContainer](hasPostAddr) ++

      postAddress.formFields.map { f => field(f,

        FormFieldId(f.uniqueFieldId.map { "post_" + _} openOr nextFuncName)) } ++

      List(c.note)

    }

    protected override def decorateLine(f: ScreenFieldInfo): CssTr =

      f.field.uniqueFieldId.filter { _.startsWith("post_") } map { _ =>

      ".control-group [class+]" #> "post-address" } openOr PassThru

    override def localSetup() { cur.foreach { c =>

      company(c)

      c.address.vend.foreach(address(_))

      c.postAddress.vend.foreach { a =>

        hasPostAddr.set(true)

        postAddress(a)

      }

    }}

    def finish() {

      hasPostAddr.get match {

        case true =>

          company.postAddress(AddressCrud.save(postAddress).$(logF).map(_.id))

        case false =>

          val p = company.postAddress.vend

          company.postAddress(Empty)

          p.foreach { AddressCrud.delete _ }

      }

      AddressCrud.save(address).$(logF).foreach { a =>

        save(company.address(a.id)).$(logF).foreach { c =>

          S notice l10n("Company %s saved.", c.linkName)

          S.redirectTo(viewLoc.calcHref(c))

        }

      }

    }

  }

  private def logF[T]: Box[T] => Unit = _ match {

    case Failure(m, _, _) => S error m

    case _ =>

  }

  private object deleteF extends HorizontalScreen with CancelButton with

    DeleteButton {

    val confirm = field(l10n("Really delete this company?"), false)

    def finish() {

      for {

        c <- deleteLoc.currentValue if confirm

        r <- delete(c)

        n <- r.box(c.linkName)

      } {

        c.address.vend.flatMap(AddressCrud.delete _) $ logF

        c.postAddress.vend.flatMap(AddressCrud.delete _) $ logF

        S notice l10n("Company %s deleted.", n)

        S redirectTo listM.loc.calcDefaultHref

      }

    }

  }

  /* Contacts view + add contact op. */

  private object contacts {

    private val choosePreM = Menu.param[Company]("company.addContact",

      l10n("Add contact"), parse, encode) / prefix / * / "add-contact" >>

      Title(c => i18n("Add contact to %s", c.linkName)) >>

      IfLoggedIn.testVal >>

      locTpl("company/add-contact") >> Snippet("panel", chooseContact) >> Hidden

    val confirmM = Menu.params[(Company, Contact)](

      "company.addContactId", l10n("Add contact"), { _ match {

        case AsLong(cmpId) :: AsLong(cntId) :: Nil => for {

            comp <- get(cmpId)

            cnt <- ContactCrud.get(cntId)

          } yield (comp, cnt)

        case _ => Empty

      }},

      { p => List(p._1, p._2) map(_.id.toString) }) / prefix /

        * / "add-contact" / * >>

      Title(p => i18n("Add contact %s to %s", p._2.linkName, p._1.linkName)) >>

      IfLoggedIn.testVal >>

      locTpl("entity/form") >> Snippet("form", addContact) >> Hidden

    val chooseM = choosePreM >> SecNav(viewPre).build

    private case class RemoveContactLink(comp: Company, cnt: Contact) extends

      ReadOnlyField("actions", "", ConfirmationLink(i18n("Remove"),

        l10n("Really remove contact?"), {

          CrmSchema.companyContacts.left(comp).dissociate(cnt)

          RedirectTo(viewLoc.calcHref(comp))

        }), Empty)

    def contacts: CssTr = "*" #> cur.map { c =>

      FieldTable[Contact]({ cnt => ContactTable.fields(cnt).toSeq ++

        (User.get.map { _ => RemoveContactLink(c, cnt) }) }, Contact)(

        CompanyContacts(c)) }

    private case class AddContactLink(comp: Company, cnt: Contact) extends

      EntityLink[Contact](cnt,

        { c => Full(confirmM.toLoc.calcHref((comp, cnt))) })

    private def chooseContact: CssTr = "*" #> chooseM.toLoc.currentValue.map {

      comp =>

        FieldTable[Contact]({ c =>

          List(AddContactLink(comp, c)) }, Contact)(CrmSchema.allContacts)

    }

    private object addContact extends HorizontalScreen with CancelButton

      with SaveButton {

      override def screenFields: List[BaseField] = (for {

        (comp, cnt) <- confirmM.toLoc.currentValue

        cl <- EntityLink(comp)

        cntl <- EntityLink(cnt)

      } yield {

        List(ReadOnlyField(l10n("Company"), cl),

          ReadOnlyField(l10n("Contact"), cntl)) flatMap(_.allFields)

      }) openOr Nil

      def finish() { for {

        (comp, cnt) <- confirmM.toLoc.currentValue

      } {

        val fk = CrmSchema.companyContacts.left(comp)

        fk.exists(_.id == cnt.id) match {

          case true =>

            S notice l10n("Contact %s is already associated with %s",

              cnt.linkName, comp.linkName)

          case false =>

            fk.associate(cnt)

            S notice l10n("Added contact %s", cnt.linkName)

        }

        S redirectTo viewLoc.calcHref(comp)

      }}

    }

  }

}

// vim: set ts=2 sw=2 et: