//-
    Licensed to the Apache Software Foundation (ASF) under one or more
    contributor license agreements.  See the NOTICE file distributed with
    this work for additional information regarding copyright ownership.
    The ASF licenses this file to You 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.

include /app/helpers/jade/mixins
include /app/configuration/mixins

-var form = 'store'
-var model = '$ctrl.clonedCache'

panel-collapsible(ng-form=form on-open=`ui.loadPanel('${form}')`)
    panel-title Store
    panel-description
        | Cache store settings.
        | #[a.link-success(href="https://apacheignite.readme.io/docs/3rd-party-store" target="_blank") More info]
    panel-content.pca-form-row(ng-if=`ui.isPanelLoaded('${form}')`)
        .pca-form-column-6.pc-form-grid-row
            -var storeFactory = `${model}.cacheStoreFactory`;
            -var storeFactoryKind = `${storeFactory}.kind`;
            .pc-form-grid-col-60
                +form-field__dropdown({
                    label: 'Store factory:',
                    model: storeFactoryKind,
                    name: '"cacheStoreFactory"',
                    placeholder: '{{ ::$ctrl.Caches.cacheStoreFactory.kind.default }}',
                    options: '::$ctrl.Caches.cacheStoreFactory.values',
                    tip: `Factory for persistent storage for cache data
                    <ul>
                        <li>JDBC POJO store factory - Objects are stored in underlying database by using java beans mapping description via reflection backed by JDBC</li>
                        <li>JDBC BLOB store factory - Objects are stored in underlying database in BLOB format backed by JDBC</li>
                        <li>Hibernate BLOB store factory - Objects are stored in underlying database in BLOB format backed by Hibernate</li>
                    </ul>`
                })(
                ui-validate=`{
                        writeThroughOn: '$ctrl.Caches.cacheStoreFactory.storeDisabledValueOff(${model}, ${model}.writeThrough)',
                        readThroughOn: '$ctrl.Caches.cacheStoreFactory.storeDisabledValueOff(${model}, ${model}.readThrough)',
                        writeBehindOn: '$ctrl.Caches.cacheStoreFactory.storeDisabledValueOff(${model}, ${model}.writeBehindEnabled)'
                    }`
                ui-validate-watch-collection=`"[${model}.readThrough, ${model}.writeThrough, ${model}.writeBehindEnabled]"`
                ng-model-options='{allowInvalid: true}'
                )
                    +form-field__error({ error: 'writeThroughOn', message: 'Write through is enabled but store is not set' })
                    +form-field__error({ error: 'readThroughOn', message: 'Read through is enabled but store is not set' })
                    +form-field__error({ error: 'writeBehindOn', message: 'Write-behind is enabled but store is not set' })
            .pc-form-group(ng-if=storeFactoryKind)
                .pc-form-grid-row(ng-if=`${storeFactoryKind} === 'CacheJdbcPojoStoreFactory'`)
                    -var pojoStoreFactory = `${storeFactory}.CacheJdbcPojoStoreFactory`
                    -var required = `${storeFactoryKind} === 'CacheJdbcPojoStoreFactory'`

                    .pc-form-grid-col-30
                        +form-field__text({
                            label: 'Data source bean name:',
                            model: `${pojoStoreFactory}.dataSourceBean`,
                            name: '"pojoDataSourceBean"',
                            required: required,
                            placeholder: 'Input bean name',
                            tip: 'Name of the data source bean in Spring context'
                        })(
                            is-valid-java-identifier
                            not-java-reserved-word
                        )
                            +form-field__error({ error: 'required', message: 'Data source bean name is required' })
                            +form-field__error({ error: 'isValidJavaIdentifier', message: 'Data source bean name is not a valid Java identifier' })
                            +form-field__error({ error: 'notJavaReservedWord', message: 'Data source bean name should not be a Java reserved word' })
                    .pc-form-grid-col-30
                        +form-field__dialect({
                            label: 'Dialect:',
                            model: `${pojoStoreFactory}.dialect`,
                            name: '"pojoDialect"',
                            required,
                            tip: 'Dialect of SQL implemented by a particular RDBMS:',
                            genericDialectName: 'Generic JDBC dialect',
                            placeholder: 'Choose JDBC dialect',
                            change:`$ctrl.clearImplementationVersion(${pojoStoreFactory})`
                        })
                    .pc-form-grid-col-60(ng-if=`$ctrl.Caches.requiresProprietaryDrivers(${pojoStoreFactory})`)
                        a.link-success(ng-href=`{{ $ctrl.Caches.jdbcDriverURL(${pojoStoreFactory}) }}` target='_blank')
                            | Download JDBC drivers?
                    .pc-form-grid-col-30
                        +form-field__number({
                            label:'Batch size:',
                            model: `${pojoStoreFactory}.batchSize`,
                            name: '"pojoBatchSize"',
                            placeholder: '512',
                            min: '1',
                            tip: 'Maximum batch size for writeAll and deleteAll operations'
                        })
                    .pc-form-grid-col-30
                        +form-field__number({
                            label: 'Thread count:',
                            model: `${pojoStoreFactory}.maximumPoolSize`,
                            name: '"pojoMaximumPoolSize"',
                            placeholder: 'availableProcessors',
                            min: '1',
                            tip: 'Maximum workers thread count.<br/>\
                                 These threads are responsible for load cache.'
                        })
                    .pc-form-grid-col-30
                        +form-field__number({
                            label: 'Maximum write attempts:',
                            model: `${pojoStoreFactory}.maximumWriteAttempts`,
                            name: '"pojoMaximumWriteAttempts"',
                            placeholder: '2',
                            min: '0',
                            tip: 'Maximum write attempts in case of database error'
                        })
                    .pc-form-grid-col-30
                        +form-field__number({
                            label: 'Parallel load threshold:',
                            model: `${pojoStoreFactory}.parallelLoadCacheMinimumThreshold`,
                            name: '"pojoParallelLoadCacheMinimumThreshold"',
                            placeholder: '512',
                            min: '0',
                            tip: 'Parallel load cache minimum threshold.<br/>\
                                 If <b>0</b> then load sequentially.'
                        })
                    .pc-form-grid-col-60
                        +form-field__java-class({
                            label: 'Hasher:',
                            model: `${pojoStoreFactory}.hasher`,
                            name: '"pojoHasher"',
                            tip: 'Hash calculator',
                            validationActive: required
                        })
                    .pc-form-grid-col-60
                        +form-field__java-class({
                            label: 'Transformer:',
                            model: `${pojoStoreFactory}.transformer`,
                            name: '"pojoTransformer"',
                            tip: 'Types transformer',
                            validationActive: required
                        })
                    .pc-form-grid-col-60
                        +form-field__checkbox({
                            label: 'Escape table and filed names',
                            model:`${pojoStoreFactory}.sqlEscapeAll`,
                            name: '"sqlEscapeAll"',
                            tip: 'If enabled than all schema, table and field names will be escaped with double quotes (for example: "tableName"."fieldName").<br/>\
                                  This enforces case sensitivity for field names and also allows having special characters in table and field names.<br/>\
                                  Escaped names will be used for CacheJdbcPojoStore internal SQL queries.'
                        })
                .pc-form-grid-row(ng-if=`${storeFactoryKind} === 'CacheJdbcBlobStoreFactory'`)
                    -var blobStoreFactory = `${storeFactory}.CacheJdbcBlobStoreFactory`
                    -var blobStoreFactoryVia = `${blobStoreFactory}.connectVia`

                    .pc-form-grid-col-60
                        +form-field__dropdown({
                            label: 'Connect via:',
                            model: blobStoreFactoryVia,
                            name: '"connectVia"',
                            placeholder: 'Choose connection method',
                            options: '[\
                                                        {value: "URL", label: "URL"},\
                                                        {value: "DataSource", label: "Data source"}\
                                                    ]',
                            tip: 'You can connect to database via:\
                                                    <ul>\
                                                        <li>JDBC URL, for example: jdbc:h2:mem:myDatabase</li>\
                                                        <li>Configured data source</li>\
                                                    </ul>'
                        })

                    -var required = `${storeFactoryKind} === 'CacheJdbcBlobStoreFactory' && ${blobStoreFactoryVia} === 'URL'`

                    .pc-form-grid-col-60(ng-if-start=`${blobStoreFactoryVia} === 'URL'`)
                        +form-field__text({
                            label: 'Connection URL:',
                            model: `${blobStoreFactory}.connectionUrl`,
                            name: '"connectionUrl"',
                            required: required,
                            placeholder: 'Input URL',
                            tip: 'URL for database access, for example: jdbc:h2:mem:myDatabase'
                        })
                    .pc-form-grid-col-30
                        +form-field__text({
                            label: 'User:',
                            model: `${blobStoreFactory}.user`,
                            name: '"user"',
                            required: required,
                            placeholder: 'Input user name',
                            tip: 'User name for database access'
                        })
                    .pc-form-grid-col-30(ng-if-end)
                        .pc-form-grid__text-only-item Password will be generated as stub.

                    -var required = `${storeFactoryKind} === 'CacheJdbcBlobStoreFactory' && ${blobStoreFactoryVia} !== 'URL'`

                    .pc-form-grid-col-30(ng-if-start=`${blobStoreFactoryVia} !== 'URL'`)
                        +form-field__text({
                            label: 'Data source bean name:',
                            model: `${blobStoreFactory}.dataSourceBean`,
                            name: '"blobDataSourceBean"',
                            required: required,
                            placeholder: 'Input bean name',
                            tip: 'Name of the data source bean in Spring context'
                        })(
                        is-valid-java-identifier
                        not-java-reserved-word
                        )
                            +form-field__error({ error: 'required', message: 'Data source bean name is required' })
                            +form-field__error({ error: 'isValidJavaIdentifier', message: 'Data source bean name is not a valid Java identifier' })
                            +form-field__error({ error: 'notJavaReservedWord', message: 'Data source bean name should not be a Java reserved word' })
                    .pc-form-grid-col-30(ng-if-end)
                        +form-field__dialect({
                            label: 'Database:',
                            model: `${blobStoreFactory}.dialect`,
                            name: '"blobDialect"',
                            required,
                            tip: 'Supported databases:',
                            genericDialectName: 'Generic database',
                            placeholder: 'Choose database'
                        })
                    .pc-form-grid-col-60(ng-if=`$ctrl.Caches.requiresProprietaryDrivers(${blobStoreFactory})`)
                        a.link-success(ng-href=`{{ $ctrl.Caches.jdbcDriverURL(${blobStoreFactory}) }}` target='_blank')
                            | Download JDBC drivers?
                    .pc-form-grid-col-60
                        +form-field__checkbox({
                            label: 'Init schema',
                            model: `${blobStoreFactory}.initSchema`,
                            name: '"initSchema"',
                            tip: 'Flag indicating whether DB schema should be initialized by Ignite (default behaviour) or was explicitly created by user'
                        })
                    .pc-form-grid-col-60
                        +form-field__text({
                            label: 'Create query:',
                            model: `${blobStoreFactory}.createTableQuery`,
                            name: '"createTableQuery"',
                            placeholder: 'SQL for table creation',
                            tip: 'Query for table creation in underlying database<br/>\
                                 Default value: create table if not exists ENTRIES (key binary primary key, val binary)'
                        })
                    .pc-form-grid-col-60
                        +form-field__text({
                            label: 'Load query:',
                            model: `${blobStoreFactory}.loadQuery`,
                            name: '"loadQuery"',
                            placeholder: 'SQL for load entry',
                            tip: 'Query for entry load from underlying database<br/>\
                                 Default value: select * from ENTRIES where key=?'
                        })
                    .pc-form-grid-col-60
                        +form-field__text({
                            label: 'Insert query:',
                            model: `${blobStoreFactory}.insertQuery`,
                            name: '"insertQuery"',
                            placeholder: 'SQL for insert entry',
                            tip: 'Query for insert entry into underlying database<br/>\
                                 Default value: insert into ENTRIES (key, val) values (?, ?)'
                        })
                    .pc-form-grid-col-60
                        +form-field__text({
                            label: 'Update query:',
                            model: `${blobStoreFactory}.updateQuery`,
                            name: '"updateQuery"',
                            placeholder: 'SQL for update entry',
                            tip: 'Query for update entry in underlying database<br/>\
                                 Default value: update ENTRIES set val=? where key=?'
                        })
                    .pc-form-grid-col-60
                        +form-field__text({
                            label: 'Delete query:',
                            model: `${blobStoreFactory}.deleteQuery`,
                            name: '"deleteQuery"',
                            placeholder: 'SQL for delete entry',
                            tip: 'Query for delete entry from underlying database<br/>\
                                 Default value: delete from ENTRIES where key=?'
                        })

                .pc-form-grid-row(ng-if=`${storeFactoryKind} === 'CacheHibernateBlobStoreFactory'`)
                    -var hibernateStoreFactory = `${storeFactory}.CacheHibernateBlobStoreFactory`

                    .pc-form-grid-col-60
                        .ignite-form-field
                            +form-field__label({ label: 'Hibernate properties:', name: '"hibernateProperties"' })
                                +form-field__tooltip({ title: `List of Hibernate properties<bt />
                                    For example: connection.url=jdbc:h2:mem:exampleDb` })

                            +list-pair-edit({
                                items: `${hibernateStoreFactory}.hibernateProperties`,
                                keyLbl: 'Property name',
                                valLbl: 'Property value',
                                itemName: 'property',
                                itemsName: 'properties'
                            })

            - form = 'store'
            .pc-form-grid-col-60
                +form-field__number({
                    label: 'Concurrent load all threshold:',
                    model: `${model}.storeConcurrentLoadAllThreshold`,
                    name: '"storeConcurrentLoadAllThreshold"',
                    placeholder: '5',
                    min: '1',
                    tip: 'Threshold used in cases when values for multiple keys are being loaded from an underlying cache store in parallel'
                })
            .pc-form-grid-col-60
                +form-field__checkbox({
                    label: 'Keep binary in store',
                    model: `${model}.storeKeepBinary`,
                    name: '"storeKeepBinary"',
                    tip: 'Flag indicating that CacheStore implementation is working with binary objects instead of Java objects'
                })
            .pc-form-grid-col-60
                +form-field__checkbox({
                    label: 'Load previous value',
                    model: `${model}.loadPreviousValue`,
                    name: '"loadPreviousValue"',
                    tip: 'Flag indicating whether value should be loaded from store if it is not in the cache for following cache operations: \
                        <ul> \
                            <li>IgniteCache.putIfAbsent()</li> \
                            <li>IgniteCache.replace()</li> \
                            <li>IgniteCache.remove()</li> \
                            <li>IgniteCache.getAndPut()</li> \
                            <li>IgniteCache.getAndRemove()</li> \
                            <li>IgniteCache.getAndReplace()</li> \
                            <li> IgniteCache.getAndPutIfAbsent()</li>\
                        </ul>'
                })
            .pc-form-grid-col-60
                +form-field__checkbox({
                    label: 'Read-through',
                    model: `${model}.readThrough`,
                    name: '"readThrough"',
                    tip: 'Flag indicating whether read-through caching should be used'
                })(
                ng-model-options='{allowInvalid: true}'
                ui-validate=`{
                        storeEnabledReadOrWriteOn: '$ctrl.Caches.cacheStoreFactory.storeEnabledReadOrWriteOn(${model})'
                    }`
                ui-validate-watch-collection=`"[${storeFactoryKind}, ${model}.writeThrough, ${model}.readThrough]"`
                )
                    +form-field__error({ error: 'storeEnabledReadOrWriteOn', message: 'Read or write through should be turned on when store kind is set' })
            .pc-form-grid-col-60
                +form-field__checkbox({
                    label: 'Write-through',
                    model: `${model}.writeThrough`,
                    name: '"writeThrough"',
                    tip: 'Flag indicating whether write-through caching should be used'
                })(
                ng-model-options='{allowInvalid: true}'
                ui-validate=`{
                        storeEnabledReadOrWriteOn: '$ctrl.Caches.cacheStoreFactory.storeEnabledReadOrWriteOn(${model})'
                    }`
                ui-validate-watch-collection=`"[${storeFactoryKind}, ${model}.writeThrough, ${model}.readThrough]"`
                )
                    +form-field__error({ error: 'storeEnabledReadOrWriteOn', message: 'Read or write through should be turned on when store kind is set' })

            -var enabled = `${model}.writeBehindEnabled`

            .pc-form-grid-col-60.pc-form-group__text-title
                +form-field__checkbox({
                    label: 'Write-behind',
                    model: enabled,
                    name: '"writeBehindEnabled"',
                    tip: `
                        Cache write-behind settings.<br>
                        Write-behind is a special mode when updates to cache accumulated and then asynchronously flushed to persistent store as a bulk operation.
                    `
                })(
                ng-model-options='{allowInvalid: true}'
                )
                    +form-field__error({ error: 'storeDisabledValueOff', message: 'Write-behind is enabled but store kind is not set' })
            .pc-form-group.pc-form-grid-row(ng-if=enabled)
                .pc-form-grid-col-30
                    +form-field__number({
                        label: 'Batch size:',
                        model: `${model}.writeBehindBatchSize`,
                        name: '"writeBehindBatchSize"',
                        disabled: `!(${enabled})`,
                        placeholder: '512',
                        min: '1',
                        tip: 'Maximum batch size for write-behind cache store operations<br/>\
                              Store operations(get or remove) are combined in a batch of this size to be passed to cache store'
                    })
                .pc-form-grid-col-30
                    +form-field__number({
                        label: 'Flush size:',
                        model: `${model}.writeBehindFlushSize`,
                        name: '"writeBehindFlushSize"',
                        placeholder: '10240',
                        min: `{{ $ctrl.Caches.writeBehindFlush.min(${model}) }}`,
                        tip: `Maximum size of the write-behind cache<br/>
                         If cache size exceeds this value, all cached items are flushed to the cache store and write cache is cleared`
                    })(
                    ng-model-options='{allowInvalid: true}'
                    )
                .pc-form-grid-col-30
                    +form-field__number({
                        label: 'Flush frequency:',
                        model: `${model}.writeBehindFlushFrequency`,
                        name: '"writeBehindFlushFrequency"',
                        placeholder: '5000',
                        min: `{{ $ctrl.Caches.writeBehindFlush.min(${model}) }}`,
                        tip: `Frequency with which write-behind cache is flushed to the cache store in milliseconds`
                    })(
                    ng-model-options='{allowInvalid: true}'
                    )
                .pc-form-grid-col-30
                    +form-field__number({
                        label: 'Flush threads count:',
                        model: `${model}.writeBehindFlushThreadCount`,
                        name: '"writeBehindFlushThreadCount"',
                        disabled: `!(${enabled})`,
                        placeholder: '1',
                        min: '1',
                        tip: 'Number of threads that will perform cache flushing'
                    })

                //- Since ignite 2.0
                .pc-form-grid-col-60(ng-if='$ctrl.available("2.0.0")')
                    +form-field__checkbox({
                        label: 'Write coalescing',
                        model: model + '.writeBehindCoalescing',
                        name: '"WriteBehindCoalescing"',
                        disabled: `!${enabled}`,
                        tip: 'Write coalescing flag for write-behind cache store'
                    })

        .pca-form-column-6
            +preview-xml-java(model, 'cacheStore', 'domains')