/*

 * Copyright 2011-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.model

import fis.base.model.{BaseSchema, Entity}

import fis.geo.model.GeoSchema

import net.liftweb.squerylrecord.RecordTypeMode._

  val contactT = tableWithSeq[Contact]

  def allContacts: Iterable[Contact] = from(contactT) (c =>

    select(c) orderBy(c.lastName asc, c.firstName asc)

  )

  /*

  val entityContacts = manyToManyRelation(entities, contacts).

    via[EntityContact]((e, c, ec) => (

      e.id === ec.entityId,

      c.id === ec.contactId

    ))

  entityContacts.leftForeignKeyDeclaration.unConstrainReference

  val contactTypeToEntityContacts = oneToManyRelation(codeListItems,

    entityContacts).via((cli, ec) => cli.id === ec.typeId)

  */

  val companyT = tableWithSeq[Company]

  val companyAddress = oneToManyRelation(addressT, companyT).

    via((a, c) => c.address === a.id)

  val companyPostAddress = oneToManyRelation(addressT, companyT).

    via((a, c) => c.postAddress === a.id)

  companyPostAddress.foreignKeyDeclaration.constrainReference(onDelete setNull)

  val bankAccountT = tableWithSeq[BankAccount]

  val companyBankAccounts = oneToManyRelation(companyT, bankAccountT).

    via((c, a) => c.id === a.company)

  companyBankAccounts.foreignKeyDeclaration.constrainReference(onDelete cascade)

  val companyContacts = manyToManyRelation(companyT, contactT).

    via[CompanyContact]((comp, cnt, cc) => (

      comp.id === cc.entity,

      cnt.id  === cc.contact

    ))

  companyContacts.leftForeignKeyDeclaration.constrainReference(onDelete cascade)

  companyContacts.rightForeignKeyDeclaration.constrainReference(onDelete cascade)

  ContactEntities.register(companyContacts)

  Company.companies.default.set { () => from(companyT)(c =>

    select(c) orderBy(c.name asc)) }

}

object CrmSchema extends CrmSchema

object CompanyContacts {

  def apply(company: Company): Iterable[Contact] =

    from(CrmSchema.companyContacts.left(company)) (c =>

      select(c) orderBy(c.lastName asc, c.firstName asc)

    )

}

import org.squeryl.KeyedEntity

import org.squeryl.dsl._

object ContactEntities {

  type T = ManyToManyRelation[Entity[_], Contact, _]

  import java.util.concurrent.{ConcurrentHashMap => CHash}

  import scala.collection.JavaConversions._

  private val rels = new CHash[String, T]

  def register[L <: Entity[_], A <: KeyedEntity[_]](

    rel: ManyToManyRelation[L, Contact, A])(implicit man:Manifest[L]) {

    rels.put(man.toString, rel.asInstanceOf[T])

  }

  def apply(c: Contact): Iterable[Entity[_]] = rels.values flatMap { _.right(c) }

}

trait EntityContact[T] extends KeyedEntity[CompositeKey2[Long, Long]] {

  def entity: Long

  def contact: Long

  def id = CompositeKey2(entity, contact)

}

case class CompanyContact(entity: Long, contact: Long) extends

  EntityContact[Company]

case class EntityContactWithType[T](val entityId: Long, val contactId: Long,

  val typeId: Long) extends KeyedEntity[CompositeKey3[Long, Long, Long]] {

  def id = CompositeKey3(entityId, contactId, typeId)

}

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